AI/ML
Awesome Claude Skills
A curated list of awesome Claude Skills, resources, and tools for customizing Claude AI workflows
npx skills add ComposioHQ/awesome-claude-skillsSkill Details
A comprehensive and curated list of 1000+ production ready and practical Claude Skills and Plugins for enhancing productivity across usecases on not just Claude.ai, Claude Code, but also across coding agents like Codex, Cursor, Gemini CLI, Antigravity and more.
Give your skills real-world actions
Skills tell your agent how to work. An MCP Gateway gives it secure access to the tools it needs.
Composio MCP Gateway provides a single MCP endpoint for 1,000+ integrations with built-in authentication, team-based access controls, audit logs, and production-ready reliability.
Quickstart: Connect Claude to 1000+ Apps
The connect-apps plugin lets Claude perform real actions - send emails, create issues, post to Slack. It handles auth and connects to 1000+ apps using Composio under the hood.
1. Install the Plugin
claude --plugin-dir ./connect-apps-plugin
2. Run Setup
/connect-apps:setup
Paste your API key when asked. (Get a free key at dashboard.composio.dev)
3. Restart & Try It
exit
claude
Want skills that do more than generate text? Claude can send emails, create issues, post to Slack, and take actions across 1000+ apps. See how →
If you receive the email, Claude is now connected to 1000+ apps.
Contents
What Are Claude Skills?
Claude Skills are reusable instruction packages that teach an AI agent how to handle a specific class of tasks. Each skill is a folder containing a SKILL.md file with YAML frontmatter (name, description) and Markdown instructions, optionally bundled with scripts, references, and assets. Anthropic introduced the format in October 2025 and released it as an open standard in December 2025; it's now supported by Claude Code, Claude.ai, the Claude API, OpenAI Codex, Cursor, Gemini CLI, Antigravity, and Windsurf.
Skills load progressively. At session start, the agent sees only each skill's name and description — roughly 100 tokens per skill. The full SKILL.md body (typically under 5,000 tokens) loads only when the agent decides the skill is relevant to the current task. Auxiliary files in scripts/ and references/ load on demand. This is what lets a single agent host hundreds of skills without bloating its context window.
Skills are not MCP servers and not tools. MCP defines how an agent connects to external systems — auth, transport, tool discovery. Tools are the individual functions an agent invokes. Skills define the workflow — what to do, in what order, with what guardrails — once the agent has the connections and tools it needs. In production, all three layers run together: MCP for access, tools for actions, skills for behavior.
Skills
Document Processing
- docx - Create, edit, analyze Word docs with tracked changes, comments, formatting.
- pdf - Extract text, tables, metadata, merge & annotate PDFs.
- pptx - Read, generate, and adjust slides, layouts, templates.
- xlsx - Spreadsheet manipulation: formulas, charts, data transformations.
- Markdown to EPUB Converter - Converts markdown documents and chat summaries into professional EPUB ebook files. By @smerchek
- Master Claude for Legal - Skill pack for legal teams. NDA triage, multi-party version diff, citation verifier, meeting brief, and the Friday-newsletter status synthesis pattern. Includes 10 reference docs (privilege, verification, long documents, practice areas) and 3 firm templates. Built from the public Anthropic Claude for Legal Teams webinar dataset. By @sboghossian
Development & Code Tools
- artifacts-builder - Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui).
- aws-skills - AWS development with CDK best practices, cost optimization MCP servers, and serverless/event-driven architecture patterns.
- building-blog - Adds an SEO-first, i18n-ready blog to a Next.js + Sanity site via a 40-question intake, a one-page plan, and a 20-section spec. Includes a generator for AI hero images via Gemini 3 Pro Image (Nano Banana Pro). By @BuildShipGrowRepeat
- Changelog Generator - Automatically creates user-facing changelogs from git commits by analyzing history and transforming technical commits into customer-friendly release notes.
- Chrome Relay - Drives the user's already-open Chrome session — cookies, SSO, extensions, localhost — through a local CLI bridge. Real-Chrome counterpart to Playwright Browser Automation; install via
npx skills add chrome-relay+ a Chrome Web Store extension. No remote relay, no Playwright fixtures, no MCP server needed. - Claude Code Terminal Title - Gives each Claud-Code terminal window a dynamic title that describes the work being done so you don't lose track of what window is doing what.
- Connect - Connect Claude to any app. Send emails, create issues, post messages, update databases - take real actions across Gmail, Slack, GitHub, Notion, and 1000+ services.
- D3.js Visualization - Teaches Claude to produce D3 charts and interactive data visualizations. By @chrisvoncsefalvay
- FFUF Web Fuzzing - Integrates the ffuf web fuzzer so Claude can run fuzzing tasks and analyze results for vulnerabilities. By @jthack
- finishing-a-development-branch - Guides completion of development work by presenting clear options and handling chosen workflow.
- Full-Page Screenshot - Captures full-page screenshots of web pages via Chrome DevTools Protocol with zero dependencies. By @LewisLiu007
- great_cto - Claude Code plugin: 7 specialised subagents (tech-lead, senior-dev, qa-engineer, security-officer, devops, l3-support, project-auditor) orchestrating a full SDLC pipeline — architecture, TDD, 12-angle code review, QA, security audit, deploy. 11 project archetypes auto-detected, 13 compliance frameworks (GDPR/PCI-DSS/HIPAA/SOC2/ISO 27001), self-improving knowledge layer that learns from every incident. By @avelikiy
- iOS Simulator - Enables Claude to interact with iOS Simulator for testing and debugging iOS applications. By @conorluddy
- jules - Delegate coding tasks to Google Jules AI agent for async bug fixes, documentation, tests, and feature implementation on GitHub repos. By @sanjay3290
- LangSmith Fetch - Debug LangChain and LangGraph agents by automatically fetching and analyzing execution traces from LangSmith Studio. First AI observability skill for Claude Code. By @OthmanAdi
- lean-ctx - MCP server and context runtime for AI coding agents: session caching, AST-aware compression, and 90+ shell patterns to reduce token usage. Supports Claude Code, Cursor, Copilot, and other integrations. Install the Claude Code skill with
lean-ctx init --agent claude-code; docs at leanctx.com. By @yvgude - MCP Builder - Guides creation of high-quality MCP (Model Context Protocol) servers for integrating external APIs and services with LLMs using Python or TypeScript.
- move-code-quality-skill - Analyzes Move language packages against the official Move Book Code Quality Checklist for Move 2024 Edition compliance and best practices.
- OpenWeb - Agent-native way to access any website. Calls the same APIs the website calls (JSON in, JSON out) with auth (cookies, JWT, CSRF, signing) auto-resolved per request. 90+ sites built in. By @openweb-org
- overkill - Surfaces advanced, maximalist alternatives to whatever solution is being discussed — advanced data structures, distributed-systems algorithms, niche frameworks, design patterns, and frontier tooling — each ranked on a calibrated complexity scale with learning links and the scenario in which the path pays off. By @santiago-vargas-de-kruijf
- Playwright Browser Automation - Model-invoked Playwright automation for testing and validating web applications. By @lackeyjb
- prompt-engineering - Teaches well-known prompt engineering techniques and patterns, including Anthropic best practices and agent persuasion principles.
- pypict-claude-skill - Design comprehensive test cases using PICT (Pairwise Independent Combinatorial Testing) for requirements or code, generating optimized test suites with pairwise coverage.
- reddit-fetch - Fetches Reddit content via Gemini CLI when WebFetch is blocked or returns 403 errors.
- Septim Agents Pack - 10 named Claude Code sub-agents (Atlas, Luca, Canon, Ember, Tally, Nova, Ward, Mira, Juno, Pip) covering planning, architecture, brand, marketing, finance, design, legal, customer, research, and coordination. Drop into
.claude/agents/. By @septimlabs-code - Skill Creator - Provides guidance for creating effective Claude Skills that extend capabilities with specialized knowledge, workflows, and tool integrations.
- Skill Seekers - Automatically converts any documentation website into a Claude AI skill in minutes. By @yusufkaraaslan
- software-architecture - Implements design patterns including Clean Architecture, SOLID principles, and comprehensive software design best practices.
- subagent-driven-development - Dispatches independent subagents for individual tasks with code review checkpoints between iterations for rapid, controlled development.
- test-driven-development - Use when implementing any feature or bugfix, before writing implementation code.
- using-git-worktrees - Creates isolated git worktrees with smart directory selection and safety verification.
- Webapp Testing - Tests local web applications using Playwright for verifying frontend functionality, debugging UI behavior, and capturing screenshots.
Data & Analysis
- CSV Data Summarizer - Automatically analyzes CSV files and generates comprehensive insights with visualizations without requiring user prompts. By @coffeefuelbump
- deep-research - Execute autonomous multi-step research using Gemini Deep Research Agent for market analysis, competitive landscaping, and literature reviews. By @sanjay3290
- postgres - Execute safe read-only SQL queries against PostgreSQL databases with multi-connection support and defense-in-depth security. By @sanjay3290
- recursive-research - Recursive research up to PhD level across any domain (science, tech, business, arts, humanities) with source tiering, WDM + Munger inversion for autonomous decisions, and disk checkpointing to survive context compaction. By @Anjos2
- root-cause-tracing - Use when errors occur deep in execution and you need to trace back to find the original trigger.
Business & Marketing
- Brand Build Skills - 59-skill library covering the full website lifecycle: brand, design, content, SEO, dev, ops, growth, and research. Stack-agnostic with an Ahrefs MCP-powered SEO audit suite. Includes a meta-skill for writing your own. By @rampstackco
- Brand Guidelines - Applies Anthropic's official brand colors and typography to artifacts for consistent visual identity and professional design standards.
- Competitive Ads Extractor - Extracts and analyzes competitors' ads from ad libraries to understand messaging and creative approaches that resonate.
- Domain Name Brainstormer - Generates creative domain name ideas and checks availability across multiple TLDs including .com, .io, .dev, and .ai extensions.
- Internal Comms - Helps write internal communications including 3P updates, company newsletters, FAQs, status reports, and project updates using company-specific formats.
- Lead Research Assistant - Identifies and qualifies high-quality leads by analyzing your product, searching for target companies, and providing actionable outreach strategies.
Communication & Writing
- article-extractor - Extract full article text and metadata from web pages.
- brainstorming - Transform rough ideas into fully-formed designs through structured questioning and alternative exploration.
- Content Research Writer - Assists in writing high-quality content by conducting research, adding citations, improving hooks, and providing section-by-section feedback.
- family-history-research - Provides assistance with planning family history and genealogy research projects.
- Meeting Insights Analyzer - Analyzes meeting transcripts to uncover behavioral patterns including conflict avoidance, speaking ratios, filler words, and leadership style.
- NotebookLM Integration - Lets Claude Code chat directly with NotebookLM for source-grounded answers based exclusively on uploaded documents. By @PleasePrompto
- Twitter Algorithm Optimizer - Analyze and optimize tweets for maximum reach using Twitter's open-source algorithm insights. Rewrite and edit tweets to improve engagement and visibility.
Creative & Media
- anydesign - Analyzes any image, URL, or Figma file and generates a structured
design.mdwith the full design system, component inventory, and reconstruction notes — portable to v0, Lovable, Cursor or any AI builder. By @uxKero - Canvas Design - Creates beautiful visual art in PNG and PDF documents using design philosophy and aesthetic principles for posters, designs, and static pieces.
- imagen - Generate images using Google Gemini's image generation API for UI mockups, icons, illustrations, and visual assets. By @sanjay3290
- Image Enhancer - Improves image and screenshot quality by enhancing resolution, sharpness, and clarity for professional presentations and documentation.
- Slack GIF Creator - Creates animated GIFs optimized for Slack with validators for size constraints and composable animation primitives.
- Theme Factory - Applies professional font and color themes to artifacts including slides, docs, reports, and HTML landing pages with 10 pre-set themes.
- Video Downloader - Downloads videos from YouTube and other platforms for offline viewing, editing, or archival with support for various formats and quality options.
- youtube-transcript - Fetch transcripts from YouTube videos and prepare summaries.
- swiftui-design-skill - SwiftUI 前端设计 skill — 反 AI Slop 六条铁律、设计方向顾问、品牌资产协议、五维评审。支持 Claude Code / Cursor / Codex / OpenCode 等全部 AI agent 平台。 By @wholiver
- Pixelbin-Media-Generation - Generate and edit images & videos with 85+ API portfolio and build visually appealing website pages
Productivity & Organization
- File Organizer - Intelligently organizes files and folders by understanding context, finding duplicates, and suggesting better organizational structures.
- Invoice Organizer - Automatically organizes invoices and receipts for tax preparation by reading files, extracting information, and renaming consistently.
- kaizen - Applies continuous improvement methodology with multiple analytical approaches, based on Japanese Kaizen philosophy and Lean methodology.
- n8n-skills - Enables AI assistants to directly understand and operate n8n workflows.
- Raffle Winner Picker - Randomly selects winners from lists, spreadsheets, or Google Sheets for giveaways and contests with cryptographically secure randomness.
- solo-skills - 7 bilingual (EN+中文) skills for solo founders and indie devs: launch tweets, customer emails, decision frameworks, postmortems. Each skill includes an explicit "When NOT to use" section.
- Tailored Resume Generator - Analyzes job descriptions and generates tailored resumes that highlight relevant experience, skills, and achievements to maximize interview chances.
- ship-learn-next - Skill to help iterate on what to build or learn next, based on feedback loops.
- tapestry - Interlink and summarize related documents into knowledge networks.
Collaboration & Project Management
- git-pushing - Automate git operations and repository interactions.
- google-workspace-skills - Suite of Google Workspace integrations: Gmail, Calendar, Chat, Docs, Sheets, Slides, and Drive with cross-platform OAuth. By @sanjay3290
- mercury-mcp - Cheatsheet for the Mercury (Proton) MCP tools. Message agent teammates, manage threads, create tasks, and schedule automations across coordinated agent teams. By Mercury
- outline - Search, read, create, and manage documents in Outline wiki instances (cloud or self-hosted). By @sanjay3290
- review-implementing - Evaluate code implementation plans and align with specs.
- [test-fixing](https:/
…
connect
name: connect description: Connect Claude to any app. Send emails, create issues, post messages, update databases - take real actions across Gmail, Slack, GitHub, Notion, and 1000+ services.
Connect
Connect Claude to any app. Stop generating text about what you could do - actually do it.
When to Use This Skill
Use this skill when you need Claude to:
- Send that email instead of drafting it
- Create that issue instead of describing it
- Post that message instead of suggesting it
- Update that database instead of explaining how
What Changes
| Without Connect | With Connect |
|---|---|
| "Here's a draft email..." | Sends the email |
| "You should create an issue..." | Creates the issue |
| "Post this to Slack..." | Posts it |
| "Add this to Notion..." | Adds it |
Supported Apps
1000+ integrations including:
- Email: Gmail, Outlook, SendGrid
- Chat: Slack, Discord, Teams, Telegram
- Dev: GitHub, GitLab, Jira, Linear
- Docs: Notion, Google Docs, Confluence
- Data: Sheets, Airtable, PostgreSQL
- CRM: HubSpot, Salesforce, Pipedrive
- Storage: Drive, Dropbox, S3
- Social: Twitter, LinkedIn, Reddit
Setup
1. Get API Key
Get your free key at platform.composio.dev
2. Set Environment Variable
export COMPOSIO_API_KEY="your-key"
3. Install
pip install composio # Python
npm install @composio/core # TypeScript
Done. Claude can now connect to any app.
Examples
Send Email
Email sarah@acme.com - Subject: "Shipped!" Body: "v2.0 is live, let me know if issues"
Create GitHub Issue
Create issue in my-org/repo: "Mobile timeout bug" with label:bug
Post to Slack
Post to #engineering: "Deploy complete - v2.4.0 live"
Chain Actions
Find GitHub issues labeled "bug" from this week, summarize, post to #bugs on Slack
How It Works
Uses Composio Tool Router:
- You ask Claude to do something
- Tool Router finds the right tool (1000+ options)
- OAuth handled automatically
- Action executes and returns result
Code
from composio import Composio
from claude_agent_sdk.client import ClaudeSDKClient
from claude_agent_sdk.types import ClaudeAgentOptions
import os
composio = Composio(api_key=os.environ["COMPOSIO_API_KEY"])
session = composio.create(user_id="user_123")
options = ClaudeAgentOptions(
system_prompt="You can take actions in external apps.",
mcp_servers={
"composio": {
"type": "http",
"url": session.mcp.url,
"headers": {"x-api-key": os.environ["COMPOSIO_API_KEY"]},
}
},
)
async with ClaudeSDKClient(options) as client:
await client.query("Send Slack message to #general: Hello!")
Auth Flow
First time using an app:
To send emails, I need Gmail access.
Authorize here: https://...
Say "connected" when done.
Connection persists after that.
Framework Support
| Framework | Install |
|---|---|
| Claude Agent SDK | pip install composio claude-agent-sdk |
| OpenAI Agents | pip install composio openai-agents |
| Vercel AI | npm install @composio/core @composio/vercel |
| LangChain | pip install composio-langchain |
| Any MCP Client | Use session.mcp.url |
Troubleshooting
- Auth required → Click link, authorize, say "connected"
- Action failed → Check permissions in target app
- Tool not found → Be specific: "Slack #general" not "send message"
<p align="center"> <b>Join 20,000+ developers building agents that ship</b> </p> <p align="center"> <a href="https://platform.composio.dev/?utm_source=Github&utm_content=AwesomeSkills"> <img src="https://img.shields.io/badge/Get_Started_Free-4F46E5?style=for-the-badge" alt="Get Started"/> </a> </p>
changelog-generator
name: changelog-generator description: Automatically creates user-facing changelogs from git commits by analyzing commit history, categorizing changes, and transforming technical commits into clear, customer-friendly release notes. Turns hours of manual changelog writing into minutes of automated generation.
Changelog Generator
This skill transforms technical git commits into polished, user-friendly changelogs that your customers and users will actually understand and appreciate.
When to Use This Skill
- Preparing release notes for a new version
- Creating weekly or monthly product update summaries
- Documenting changes for customers
- Writing changelog entries for app store submissions
- Generating update notifications
- Creating internal release documentation
- Maintaining a public changelog/product updates page
What This Skill Does
- Scans Git History: Analyzes commits from a specific time period or between versions
- Categorizes Changes: Groups commits into logical categories (features, improvements, bug fixes, breaking changes, security)
- Translates Technical → User-Friendly: Converts developer commits into customer language
- Formats Professionally: Creates clean, structured changelog entries
- Filters Noise: Excludes internal commits (refactoring, tests, etc.)
- Follows Best Practices: Applies changelog guidelines and your brand voice
How to Use
Basic Usage
From your project repository:
Create a changelog from commits since last release
Generate changelog for all commits from the past week
Create release notes for version 2.5.0
With Specific Date Range
Create a changelog for all commits between March 1 and March 15
With Custom Guidelines
Create a changelog for commits since v2.4.0, using my changelog
guidelines from CHANGELOG_STYLE.md
Example
User: "Create a changelog for commits from the past 7 days"
Output:
# Updates - Week of March 10, 2024
## ✨ New Features
- **Team Workspaces**: Create separate workspaces for different
projects. Invite team members and keep everything organized.
- **Keyboard Shortcuts**: Press ? to see all available shortcuts.
Navigate faster without touching your mouse.
## 🔧 Improvements
- **Faster Sync**: Files now sync 2x faster across devices
- **Better Search**: Search now includes file contents, not just titles
## 🐛 Fixes
- Fixed issue where large images wouldn't upload
- Resolved timezone confusion in scheduled posts
- Corrected notification badge count
Inspired by: Manik Aggarwal's use case from Lenny's Newsletter
Tips
- Run from your git repository root
- Specify date ranges for focused changelogs
- Use your CHANGELOG_STYLE.md for consistent formatting
- Review and adjust the generated changelog before publishing
- Save output directly to CHANGELOG.md
Related Use Cases
- Creating GitHub release notes
- Writing app store update descriptions
- Generating email updates for users
- Creating social media announcement posts
langsmith-fetch
name: langsmith-fetch description: Debug LangChain and LangGraph agents by fetching execution traces from LangSmith Studio. Use when debugging agent behavior, investigating errors, analyzing tool calls, checking memory operations, or examining agent performance. Automatically fetches recent traces and analyzes execution patterns. Requires langsmith-fetch CLI installed.
LangSmith Fetch - Agent Debugging Skill
Debug LangChain and LangGraph agents by fetching execution traces directly from LangSmith Studio in your terminal.
When to Use This Skill
Automatically activate when user mentions:
- 🐛 "Debug my agent" or "What went wrong?"
- 🔍 "Show me recent traces" or "What happened?"
- ❌ "Check for errors" or "Why did it fail?"
- 💾 "Analyze memory operations" or "Check LTM"
- 📊 "Review agent performance" or "Check token usage"
- 🔧 "What tools were called?" or "Show execution flow"
Prerequisites
1. Install langsmith-fetch
pip install langsmith-fetch
2. Set Environment Variables
export LANGSMITH_API_KEY="your_langsmith_api_key"
export LANGSMITH_PROJECT="your_project_name"
Verify setup:
echo $LANGSMITH_API_KEY
echo $LANGSMITH_PROJECT
Core Workflows
Workflow 1: Quick Debug Recent Activity
When user asks: "What just happened?" or "Debug my agent"
Execute:
langsmith-fetch traces --last-n-minutes 5 --limit 5 --format pretty
Analyze and report:
- ✅ Number of traces found
- ⚠️ Any errors or failures
- 🛠️ Tools that were called
- ⏱️ Execution times
- 💰 Token usage
Example response format:
Found 3 traces in the last 5 minutes:
Trace 1: ✅ Success
- Agent: memento
- Tools: recall_memories, create_entities
- Duration: 2.3s
- Tokens: 1,245
Trace 2: ❌ Error
- Agent: cypher
- Error: "Neo4j connection timeout"
- Duration: 15.1s
- Failed at: search_nodes tool
Trace 3: ✅ Success
- Agent: memento
- Tools: store_memory
- Duration: 1.8s
- Tokens: 892
💡 Issue found: Trace 2 failed due to Neo4j timeout. Recommend checking database connection.
Workflow 2: Deep Dive Specific Trace
When user provides: Trace ID or says "investigate that error"
Execute:
langsmith-fetch trace <trace-id> --format json
Analyze JSON and report:
- 🎯 What the agent was trying to do
- 🛠️ Which tools were called (in order)
- ✅ Tool results (success/failure)
- ❌ Error messages (if any)
- 💡 Root cause analysis
- 🔧 Suggested fix
Example response format:
Deep Dive Analysis - Trace abc123
Goal: User asked "Find all projects in Neo4j"
Execution Flow:
1. ✅ search_nodes(query: "projects")
→ Found 24 nodes
2. ❌ get_node_details(node_id: "proj_123")
→ Error: "Node not found"
→ This is the failure point
3. ⏹️ Execution stopped
Root Cause:
The search_nodes tool returned node IDs that no longer exist in the database,
possibly due to recent deletions.
Suggested Fix:
1. Add error handling in get_node_details tool
2. Filter deleted nodes in search results
3. Update cache invalidation strategy
Token Usage: 1,842 tokens ($0.0276)
Execution Time: 8.7 seconds
Workflow 3: Export Debug Session
When user says: "Save this session" or "Export traces"
Execute:
# Create session folder with timestamp
SESSION_DIR="langsmith-debug/session-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$SESSION_DIR"
# Export traces
langsmith-fetch traces "$SESSION_DIR/traces" --last-n-minutes 30 --limit 50 --include-metadata
# Export threads (conversations)
langsmith-fetch threads "$SESSION_DIR/threads" --limit 20
Report:
✅ Session exported successfully!
Location: langsmith-debug/session-20251224-143022/
- Traces: 42 files
- Threads: 8 files
You can now:
1. Review individual trace files
2. Share folder with team
3. Analyze with external tools
4. Archive for future reference
Session size: 2.3 MB
Workflow 4: Error Detection
When user asks: "Show me errors" or "What's failing?"
Execute:
# Fetch recent traces
langsmith-fetch traces --last-n-minutes 30 --limit 50 --format json > recent-traces.json
# Search for errors
grep -i "error\|failed\|exception" recent-traces.json
Analyze and report:
- 📊 Total errors found
- ❌ Error types and frequency
- 🕐 When errors occurred
- 🎯 Which agents/tools failed
- 💡 Common patterns
Example response format:
Error Analysis - Last 30 Minutes
Total Traces: 50
Failed Traces: 7 (14% failure rate)
Error Breakdown:
1. Neo4j Connection Timeout (4 occurrences)
- Agent: cypher
- Tool: search_nodes
- First occurred: 14:32
- Last occurred: 14:45
- Pattern: Happens during peak load
2. Memory Store Failed (2 occurrences)
- Agent: memento
- Tool: store_memory
- Error: "Pinecone rate limit exceeded"
- Occurred: 14:38, 14:41
3. Tool Not Found (1 occurrence)
- Agent: sqlcrm
- Attempted tool: "export_report" (doesn't exist)
- Occurred: 14:35
💡 Recommendations:
1. Add retry logic for Neo4j timeouts
2. Implement rate limiting for Pinecone
3. Fix sqlcrm tool configuration
Common Use Cases
Use Case 1: "Agent Not Responding"
User says: "My agent isn't doing anything"
Steps:
-
Check if traces exist:
langsmith-fetch traces --last-n-minutes 5 --limit 5 -
If NO traces found:
- Tracing might be disabled
- Check:
LANGCHAIN_TRACING_V2=truein environment - Check:
LANGCHAIN_API_KEYis set - Verify agent actually ran
-
If traces found:
- Review for errors
- Check execution time (hanging?)
- Verify tool calls completed
Use Case 2: "Wrong Tool Called"
User says: "Why did it use the wrong tool?"
Steps:
- Get the specific trace
- Review available tools at execution time
- Check agent's reasoning for tool selection
- Examine tool descriptions/instructions
- Suggest prompt or tool config improvements
Use Case 3: "Memory Not Working"
User says: "Agent doesn't remember things"
Steps:
-
Search for memory operations:
langsmith-fetch traces --last-n-minutes 10 --limit 20 --format raw | grep -i "memory\|recall\|store" -
Check:
- Were memory tools called?
- Did recall return results?
- Were memories actually stored?
- Are retrieved memories being used?
Use Case 4: "Performance Issues"
User says: "Agent is too slow"
Steps:
-
Export with metadata:
langsmith-fetch traces ./perf-analysis --last-n-minutes 30 --limit 50 --include-metadata -
Analyze:
- Execution time per trace
- Tool call latencies
- Token usage (context size)
- Number of iterations
- Slowest operations
-
Identify bottlenecks and suggest optimizations
Output Format Guide
Pretty Format (Default)
langsmith-fetch traces --limit 5 --format pretty
Use for: Quick visual inspection, showing to users
JSON Format
langsmith-fetch traces --limit 5 --format json
Use for: Detailed analysis, syntax-highlighted review
Raw Format
langsmith-fetch traces --limit 5 --format raw
Use for: Piping to other commands, automation
Advanced Features
Time-Based Filtering
# After specific timestamp
langsmith-fetch traces --after "2025-12-24T13:00:00Z" --limit 20
# Last N minutes (most common)
langsmith-fetch traces --last-n-minutes 60 --limit 100
Include Metadata
# Get extra context
langsmith-fetch traces --limit 10 --include-metadata
# Metadata includes: agent type, model, tags, environment
Concurrent Fetching (Faster)
# Speed up large exports
langsmith-fetch traces ./output --limit 100 --concurrent 10
Troubleshooting
"No traces found matching criteria"
Possible causes:
- No agent activity in the timeframe
- Tracing is disabled
- Wrong project name
- API key issues
Solutions:
# 1. Try longer timeframe
langsmith-fetch traces --last-n-minutes 1440 --limit 50
# 2. Check environment
echo $LANGSMITH_API_KEY
echo $LANGSMITH_PROJECT
# 3. Try fetching threads instead
langsmith-fetch threads --limit 10
# 4. Verify tracing is enabled in your code
# Check for: LANGCHAIN_TRACING_V2=true
"Project not found"
Solution:
# View current config
langsmith-fetch config show
# Set correct project
export LANGSMITH_PROJECT="correct-project-name"
# Or configure permanently
langsmith-fetch config set project "your-project-name"
Environment variables not persisting
Solution:
# Add to shell config file (~/.bashrc or ~/.zshrc)
echo 'export LANGSMITH_API_KEY="your_key"' >> ~/.bashrc
echo 'export LANGSMITH_PROJECT="your_project"' >> ~/.bashrc
# Reload shell config
source ~/.bashrc
Best Practices
1. Regular Health Checks
# Quick check after making changes
langsmith-fetch traces --last-n-minutes 5 --limit 5
2. Organized Storage
langsmith-debug/
├── sessions/
│ ├── 2025-12-24/
│ └── 2025-12-25/
├── error-cases/
└── performance-tests/
3. Document Findings
When you find bugs:
- Export the problematic trace
- Save to
error-cases/folder - Note what went wrong in a README
- Share trace ID with team
4. Integration with Development
# Before committing code
langsmith-fetch traces --last-n-minutes 10 --limit 5
# If errors found
langsmith-fetch trace <error-id> --format json > pre-commit-error.json
Quick Reference
# Most common commands
# Quick debug
langsmith-fetch traces --last-n-minutes 5 --limit 5 --format pretty
# Specific trace
langsmith-fetch trace <trace-id> --format pretty
# Export session
langsmith-fetch traces ./debug-session --last-n-minutes 30 --limit 50
# Find errors
langsmith-fetch traces --last-n-minutes 30 --limit 50 --format raw | grep -i error
# With metadata
langsmith-fetch traces --limit 10 --include-metadata
Resources
- LangSmith Fetch CLI: https://github.com/langchain-ai/langsmith-fetch
- LangSmith Studio: https://smith.langchain.com/
- LangChain Docs: https://docs.langchain.com/
- This Skill Repo: https://github.com/OthmanAdi/langsmith-fetch-skill
Notes for Claude
- Always check if
langsmith-fetchis installed before running commands - Verify environment variables are set
- Use
--format prettyfor human-readable output - Use
--format jsonwhen you need to parse and analyze data - When exporting sessions, create organized folder structures
- Always provide clear analysis and actionable insights
- If commands fail, help troubleshoot configuration issues
Version: 0.1.0 Author: Ahmad Othman Ammar Adi License: MIT Repository: https://github.com/OthmanAdi/langsmith-fetch-skill
mcp-builder
name: mcp-builder description: Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). license: Complete terms in LICENSE.txt
MCP Server Development Guide
Overview
To create high-quality MCP (Model Context Protocol) servers that enable LLMs to effectively interact with external services, use this skill. An MCP server provides tools that allow LLMs to access external services and APIs. The quality of an MCP server is measured by how well it enables LLMs to accomplish real-world tasks using the tools provided.
Process
🚀 High-Level Workflow
Creating a high-quality MCP server involves four main phases:
Phase 1: Deep Research and Planning
1.1 Understand Agent-Centric Design Principles
Before diving into implementation, understand how to design tools for AI agents by reviewing these principles:
Build for Workflows, Not Just API Endpoints:
- Don't simply wrap existing API endpoints - build thoughtful, high-impact workflow tools
- Consolidate related operations (e.g.,
schedule_eventthat both checks availability and creates event) - Focus on tools that enable complete tasks, not just individual API calls
- Consider what workflows agents actually need to accomplish
Optimize for Limited Context:
- Agents have constrained context windows - make every token count
- Return high-signal information, not exhaustive data dumps
- Provide "concise" vs "detailed" response format options
- Default to human-readable identifiers over technical codes (names over IDs)
- Consider the agent's context budget as a scarce resource
Design Actionable Error Messages:
- Error messages should guide agents toward correct usage patterns
- Suggest specific next steps: "Try using filter='active_only' to reduce results"
- Make errors educational, not just diagnostic
- Help agents learn proper tool usage through clear feedback
Follow Natural Task Subdivisions:
- Tool names should reflect how humans think about tasks
- Group related tools with consistent prefixes for discoverability
- Design tools around natural workflows, not just API structure
Use Evaluation-Driven Development:
- Create realistic evaluation scenarios early
- Let agent feedback drive tool improvements
- Prototype quickly and iterate based on actual agent performance
1.3 Study MCP Protocol Documentation
Fetch the latest MCP protocol documentation:
Use WebFetch to load: https://modelcontextprotocol.io/llms-full.txt
This comprehensive document contains the complete MCP specification and guidelines.
1.4 Study Framework Documentation
Load and read the following reference files:
- MCP Best Practices: 📋 View Best Practices - Core guidelines for all MCP servers
For Python implementations, also load:
- Python SDK Documentation: Use WebFetch to load
https://raw.githubusercontent.com/modelcontextprotocol/python-sdk/main/README.md - 🐍 Python Implementation Guide - Python-specific best practices and examples
For Node/TypeScript implementations, also load:
- TypeScript SDK Documentation: Use WebFetch to load
https://raw.githubusercontent.com/modelcontextprotocol/typescript-sdk/main/README.md - ⚡ TypeScript Implementation Guide - Node/TypeScript-specific best practices and examples
1.5 Exhaustively Study API Documentation
To integrate a service, read through ALL available API documentation:
- Official API reference documentation
- Authentication and authorization requirements
- Rate limiting and pagination patterns
- Error responses and status codes
- Available endpoints and their parameters
- Data models and schemas
To gather comprehensive information, use web search and the WebFetch tool as needed.
1.6 Create a Comprehensive Implementation Plan
Based on your research, create a detailed plan that includes:
Tool Selection:
- List the most valuable endpoints/operations to implement
- Prioritize tools that enable the most common and important use cases
- Consider which tools work together to enable complex workflows
Shared Utilities and Helpers:
- Identify common API request patterns
- Plan pagination helpers
- Design filtering and formatting utilities
- Plan error handling strategies
Input/Output Design:
- Define input validation models (Pydantic for Python, Zod for TypeScript)
- Design consistent response formats (e.g., JSON or Markdown), and configurable levels of detail (e.g., Detailed or Concise)
- Plan for large-scale usage (thousands of users/resources)
- Implement character limits and truncation strategies (e.g., 25,000 tokens)
Error Handling Strategy:
- Plan graceful failure modes
- Design clear, actionable, LLM-friendly, natural language error messages which prompt further action
- Consider rate limiting and timeout scenarios
- Handle authentication and authorization errors
Phase 2: Implementation
Now that you have a comprehensive plan, begin implementation following language-specific best practices.
2.1 Set Up Project Structure
For Python:
- Create a single
.pyfile or organize into modules if complex (see 🐍 Python Guide) - Use the MCP Python SDK for tool registration
- Define Pydantic models for input validation
For Node/TypeScript:
- Create proper project structure (see ⚡ TypeScript Guide)
- Set up
package.jsonandtsconfig.json - Use MCP TypeScript SDK
- Define Zod schemas for input validation
2.2 Implement Core Infrastructure First
To begin implementation, create shared utilities before implementing tools:
- API request helper functions
- Error handling utilities
- Response formatting functions (JSON and Markdown)
- Pagination helpers
- Authentication/token management
2.3 Implement Tools Systematically
For each tool in the plan:
Define Input Schema:
- Use Pydantic (Python) or Zod (TypeScript) for validation
- Include proper constraints (min/max length, regex patterns, min/max values, ranges)
- Provide clear, descriptive field descriptions
- Include diverse examples in field descriptions
Write Comprehensive Docstrings/Descriptions:
- One-line summary of what the tool does
- Detailed explanation of purpose and functionality
- Explicit parameter types with examples
- Complete return type schema
- Usage examples (when to use, when not to use)
- Error handling documentation, which outlines how to proceed given specific errors
Implement Tool Logic:
- Use shared utilities to avoid code duplication
- Follow async/await patterns for all I/O
- Implement proper error handling
- Support multiple response formats (JSON and Markdown)
- Respect pagination parameters
- Check character limits and truncate appropriately
Add Tool Annotations:
readOnlyHint: true (for read-only operations)destructiveHint: false (for non-destructive operations)idempotentHint: true (if repeated calls have same effect)openWorldHint: true (if interacting with external systems)
2.4 Follow Language-Specific Best Practices
At this point, load the appropriate language guide:
For Python: Load 🐍 Python Implementation Guide and ensure the following:
- Using MCP Python SDK with proper tool registration
- Pydantic v2 models with
model_config - Type hints throughout
- Async/await for all I/O operations
- Proper imports organization
- Module-level constants (CHARACTER_LIMIT, API_BASE_URL)
For Node/TypeScript: Load ⚡ TypeScript Implementation Guide and ensure the following:
- Using
server.registerToolproperly - Zod schemas with
.strict() - TypeScript strict mode enabled
- No
anytypes - use proper types - Explicit Promise<T> return types
- Build process configured (
npm run build)
Phase 3: Review and Refine
After initial implementation:
3.1 Code Quality Review
To ensure quality, review the code for:
- DRY Principle: No duplicated code between tools
- Composability: Shared logic extracted into functions
- Consistency: Similar operations return similar formats
- Error Handling: All external calls have error handling
- Type Safety: Full type coverage (Python type hints, TypeScript types)
- Documentation: Every tool has comprehensive docstrings/descriptions
3.2 Test and Build
Important: MCP servers are long-running processes that wait for requests over stdio/stdin or sse/http. Running them directly in your main process (e.g., python server.py or node dist/index.js) will cause your process to hang indefinitely.
Safe ways to test the server:
- Use the evaluation harness (see Phase 4) - recommended approach
- Run the server in tmux to keep it outside your main process
- Use a timeout when testing:
timeout 5s python server.py
For Python:
- Verify Python syntax:
python -m py_compile your_server.py - Check imports work correctly by reviewing the file
- To manually test: Run server in tmux, then test with evaluation harness in main process
- Or use the evaluation harness directly (it manages the server for stdio transport)
For Node/TypeScript:
- Run
npm run buildand ensure it completes without errors - Verify dist/index.js is created
- To manually test: Run server in tmux, then test with evaluation harness in main process
- Or use the evaluation harness directly (it manages the server for stdio transport)
3.3 Use Quality Checklist
To verify implementation quality, load the appropriate checklist from the language-specific guide:
- Python: see "Quality Checklist" in 🐍 Python Guide
- Node/TypeScript: see "Quality Checklist" in ⚡ TypeScript Guide
Phase 4: Create Evaluations
After implementing your MCP server, create comprehensive evaluations to test its effectiveness.
Load ✅ Evaluation Guide for complete evaluation guidelines.
4.1 Understand Evaluation Purpose
Evaluations test whether LLMs can effectively use your MCP server to answer realistic, complex questions.
4.2 Create 10 Evaluation Questions
To create effective evaluations, follow the process outlined in the evaluation guide:
- Tool Inspection: List available tools and understand their capabilities
- Content Exploration: Use READ-ONLY operations to explore available data
- Question Generation: Create 10 complex, realistic questions
- Answer Verification: Solve each question yourself to verify answers
4.3 Evaluation Requirements
Each question must be:
- Independent: Not dependent on other questions
- Read-only: Only non-destructive operations required
- Complex: Requiring multiple tool calls and deep exploration
- Realistic: Based on real use cases humans would care about
- Verifiable: Single, clear answer that can be verified by string comparison
- Stable: Answer won't change over time
4.4 Output Format
Create an XML file with this structure:
<evaluation>
<qa_pair>
<question>Find discussions about AI model launches with animal codenames. One model needed a specific safety designation that uses the format ASL-X. What number X was being determined for the model named after a spotted wild cat?</question>
<answer>3</answer>
</qa_pair>
<!-- More qa_pairs... -->
</evaluation>
Reference Files
📚 Documentation Library
Load these resources as needed during development:
Core MCP Documentation (Load First)
- MCP Protocol: Fetch from
https://modelcontextprotocol.io/llms-full.txt- Complete MCP specification - 📋 MCP Best Practices - Universal MCP guidelines including:
- Server and tool naming conventions
- Response format guidelines (JSON vs Markdown)
- Pagination best practices
- Character limits and truncation strategies
- Tool development guidelines
- Security and error handling standards
SDK Documentation (Load During Phase 1/2)
- Python SDK: Fetch from
https://raw.githubusercontent.com/modelcontextprotocol/python-sdk/main/README.md - TypeScript SDK: Fetch from
https://raw.githubusercontent.com/modelcontextprotocol/typescript-sdk/main/README.md
Language-Specific Implementation Guides (Load During Phase 2)
-
🐍 Python Implementation Guide - Complete Python/FastMCP guide with:
- Server initialization patterns
- Pydantic model examples
- Tool registration with
@mcp.tool - Complete working examples
- Quality checklist
-
⚡ TypeScript Implementation Guide - Complete TypeScript guide with:
- Project structure
- Zod schema patterns
- Tool registration with
server.registerTool - Complete working examples
- Quality checklist
Evaluation Guide (Load During Phase 4)
- ✅ Evaluation Guide - Complete evaluation creation guide with:
- Question creation guidelines
- Answer verification strategies
- XML format specifications
- Example questions and answers
- Running an evaluation with the provided scripts
skill-creator
name: skill-creator description: Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations. license: Complete terms in LICENSE.txt
Skill Creator
This skill provides guidance for creating effective skills.
About Skills
Skills are modular, self-contained packages that extend Claude's capabilities by providing specialized knowledge, workflows, and tools. Think of them as "onboarding guides" for specific domains or tasks—they transform Claude from a general-purpose agent into a specialized agent equipped with procedural knowledge that no model can fully possess.
What Skills Provide
- Specialized workflows - Multi-step procedures for specific domains
- Tool integrations - Instructions for working with specific file formats or APIs
- Domain expertise - Company-specific knowledge, schemas, business logic
- Bundled resources - Scripts, references, and assets for complex and repetitive tasks
Anatomy of a Skill
Every skill consists of a required SKILL.md file and optional bundled resources:
skill-name/
├── SKILL.md (required)
│ ├── YAML frontmatter metadata (required)
│ │ ├── name: (required)
│ │ └── description: (required)
│ └── Markdown instructions (required)
└── Bundled Resources (optional)
├── scripts/ - Executable code (Python/Bash/etc.)
├── references/ - Documentation intended to be loaded into context as needed
└── assets/ - Files used in output (templates, icons, fonts, etc.)
SKILL.md (required)
Metadata Quality: The name and description in YAML frontmatter determine when Claude will use the skill. Be specific about what the skill does and when to use it. Use the third-person (e.g. "This skill should be used when..." instead of "Use this skill when...").
Bundled Resources (optional)
Scripts (scripts/)
Executable code (Python/Bash/etc.) for tasks that require deterministic reliability or are repeatedly rewritten.
- When to include: When the same code is being rewritten repeatedly or deterministic reliability is needed
- Example:
scripts/rotate_pdf.pyfor PDF rotation tasks - Benefits: Token efficient, deterministic, may be executed without loading into context
- Note: Scripts may still need to be read by Claude for patching or environment-specific adjustments
References (references/)
Documentation and reference material intended to be loaded as needed into context to inform Claude's process and thinking.
- When to include: For documentation that Claude should reference while working
- Examples:
references/finance.mdfor financial schemas,references/mnda.mdfor company NDA template,references/policies.mdfor company policies,references/api_docs.mdfor API specifications - Use cases: Database schemas, API documentation, domain knowledge, company policies, detailed workflow guides
- Benefits: Keeps SKILL.md lean, loaded only when Claude determines it's needed
- Best practice: If files are large (>10k words), include grep search patterns in SKILL.md
- Avoid duplication: Information should live in either SKILL.md or references files, not both. Prefer references files for detailed information unless it's truly core to the skill—this keeps SKILL.md lean while making information discoverable without hogging the context window. Keep only essential procedural instructions and workflow guidance in SKILL.md; move detailed reference material, schemas, and examples to references files.
Assets (assets/)
Files not intended to be loaded into context, but rather used within the output Claude produces.
- When to include: When the skill needs files that will be used in the final output
- Examples:
assets/logo.pngfor brand assets,assets/slides.pptxfor PowerPoint templates,assets/frontend-template/for HTML/React boilerplate,assets/font.ttffor typography - Use cases: Templates, images, icons, boilerplate code, fonts, sample documents that get copied or modified
- Benefits: Separates output resources from documentation, enables Claude to use files without loading them into context
Progressive Disclosure Design Principle
Skills use a three-level loading system to manage context efficiently:
- Metadata (name + description) - Always in context (~100 words)
- SKILL.md body - When skill triggers (<5k words)
- Bundled resources - As needed by Claude (Unlimited*)
*Unlimited because scripts can be executed without reading into context window.
Skill Creation Process
To create a skill, follow the "Skill Creation Process" in order, skipping steps only if there is a clear reason why they are not applicable.
Step 1: Understanding the Skill with Concrete Examples
Skip this step only when the skill's usage patterns are already clearly understood. It remains valuable even when working with an existing skill.
To create an effective skill, clearly understand concrete examples of how the skill will be used. This understanding can come from either direct user examples or generated examples that are validated with user feedback.
For example, when building an image-editor skill, relevant questions include:
- "What functionality should the image-editor skill support? Editing, rotating, anything else?"
- "Can you give some examples of how this skill would be used?"
- "I can imagine users asking for things like 'Remove the red-eye from this image' or 'Rotate this image'. Are there other ways you imagine this skill being used?"
- "What would a user say that should trigger this skill?"
To avoid overwhelming users, avoid asking too many questions in a single message. Start with the most important questions and follow up as needed for better effectiveness.
Conclude this step when there is a clear sense of the functionality the skill should support.
Step 2: Planning the Reusable Skill Contents
To turn concrete examples into an effective skill, analyze each example by:
- Considering how to execute on the example from scratch
- Identifying what scripts, references, and assets would be helpful when executing these workflows repeatedly
Example: When building a pdf-editor skill to handle queries like "Help me rotate this PDF," the analysis shows:
- Rotating a PDF requires re-writing the same code each time
- A
scripts/rotate_pdf.pyscript would be helpful to store in the skill
Example: When designing a frontend-webapp-builder skill for queries like "Build me a todo app" or "Build me a dashboard to track my steps," the analysis shows:
- Writing a frontend webapp requires the same boilerplate HTML/React each time
- An
assets/hello-world/template containing the boilerplate HTML/React project files would be helpful to store in the skill
Example: When building a big-query skill to handle queries like "How many users have logged in today?" the analysis shows:
- Querying BigQuery requires re-discovering the table schemas and relationships each time
- A
references/schema.mdfile documenting the table schemas would be helpful to store in the skill
To establish the skill's contents, analyze each concrete example to create a list of the reusable resources to include: scripts, references, and assets.
Step 3: Initializing the Skill
At this point, it is time to actually create the skill.
Skip this step only if the skill being developed already exists, and iteration or packaging is needed. In this case, continue to the next step.
When creating a new skill from scratch, always run the init_skill.py script. The script conveniently generates a new template skill directory that automatically includes everything a skill requires, making the skill creation process much more efficient and reliable.
Usage:
scripts/init_skill.py <skill-name> --path <output-directory>
The script:
- Creates the skill directory at the specified path
- Generates a SKILL.md template with proper frontmatter and TODO placeholders
- Creates example resource directories:
scripts/,references/, andassets/ - Adds example files in each directory that can be customized or deleted
After initialization, customize or remove the generated SKILL.md and example files as needed.
Step 4: Edit the Skill
When editing the (newly-generated or existing) skill, remember that the skill is being created for another instance of Claude to use. Focus on including information that would be beneficial and non-obvious to Claude. Consider what procedural knowledge, domain-specific details, or reusable assets would help another Claude instance execute these tasks more effectively.
Start with Reusable Skill Contents
To begin implementation, start with the reusable resources identified above: scripts/, references/, and assets/ files. Note that this step may require user input. For example, when implementing a brand-guidelines skill, the user may need to provide brand assets or templates to store in assets/, or documentation to store in references/.
Also, delete any example files and directories not needed for the skill. The initialization script creates example files in scripts/, references/, and assets/ to demonstrate structure, but most skills won't need all of them.
Update SKILL.md
Writing Style: Write the entire skill using imperative/infinitive form (verb-first instructions), not second person. Use objective, instructional language (e.g., "To accomplish X, do Y" rather than "You should do X" or "If you need to do X"). This maintains consistency and clarity for AI consumption.
To complete SKILL.md, answer the following questions:
- What is the purpose of the skill, in a few sentences?
- When should the skill be used?
- In practice, how should Claude use the skill? All reusable skill contents developed above should be referenced so that Claude knows how to use them.
Step 5: Packaging a Skill
Once the skill is ready, it should be packaged into a distributable zip file that gets shared with the user. The packaging process automatically validates the skill first to ensure it meets all requirements:
scripts/package_skill.py <path/to/skill-folder>
Optional output directory specification:
scripts/package_skill.py <path/to/skill-folder> ./dist
The packaging script will:
-
Validate the skill automatically, checking:
- YAML frontmatter format and required fields
- Skill naming conventions and directory structure
- Description completeness and quality
- File organization and resource references
-
Package the skill if validation passes, creating a zip file named after the skill (e.g.,
my-skill.zip) that includes all files and maintains the proper directory structure for distribution.
If validation fails, the script will report the errors and exit without creating a package. Fix any validation errors and run the packaging command again.
Step 6: Iterate
After testing the skill, users may request improvements. Often this happens right after using the skill, with fresh context of how the skill performed.
Iteration workflow:
- Use the skill on real tasks
- Notice struggles or inefficiencies
- Identify how SKILL.md or bundled resources should be updated
- Implement changes and test again
webapp-testing
name: webapp-testing description: Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs. license: Complete terms in LICENSE.txt
Web Application Testing
To test local web applications, write native Python Playwright scripts.
Helper Scripts Available:
scripts/with_server.py- Manages server lifecycle (supports multiple servers)
Always run scripts with --help first to see usage. DO NOT read the source until you try running the script first and find that a customized solution is abslutely necessary. These scripts can be very large and thus pollute your context window. They exist to be called directly as black-box scripts rather than ingested into your context window.
Decision Tree: Choosing Your Approach
User task → Is it static HTML?
├─ Yes → Read HTML file directly to identify selectors
│ ├─ Success → Write Playwright script using selectors
│ └─ Fails/Incomplete → Treat as dynamic (below)
│
└─ No (dynamic webapp) → Is the server already running?
├─ No → Run: python scripts/with_server.py --help
│ Then use the helper + write simplified Playwright script
│
└─ Yes → Reconnaissance-then-action:
1. Navigate and wait for networkidle
2. Take screenshot or inspect DOM
3. Identify selectors from rendered state
4. Execute actions with discovered selectors
Example: Using with_server.py
To start a server, run --help first, then use the helper:
Single server:
python scripts/with_server.py --server "npm run dev" --port 5173 -- python your_automation.py
Multiple servers (e.g., backend + frontend):
python scripts/with_server.py \
--server "cd backend && python server.py" --port 3000 \
--server "cd frontend && npm run dev" --port 5173 \
-- python your_automation.py
To create an automation script, include only Playwright logic (servers are managed automatically):
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch(headless=True) # Always launch chromium in headless mode
page = browser.new_page()
page.goto('http://localhost:5173') # Server already running and ready
page.wait_for_load_state('networkidle') # CRITICAL: Wait for JS to execute
# ... your automation logic
browser.close()
Reconnaissance-Then-Action Pattern
-
Inspect rendered DOM:
page.screenshot(path='/tmp/inspect.png', full_page=True) content = page.content() page.locator('button').all() -
Identify selectors from inspection results
-
Execute actions using discovered selectors
Common Pitfall
❌ Don't inspect the DOM before waiting for networkidle on dynamic apps
✅ Do wait for page.wait_for_load_state('networkidle') before inspection
Best Practices
- Use bundled scripts as black boxes - To accomplish a task, consider whether one of the scripts available in
scripts/can help. These scripts handle common, complex workflows reliably without cluttering the context window. Use--helpto see usage, then invoke directly. - Use
sync_playwright()for synchronous scripts - Always close the browser when done
- Use descriptive selectors:
text=,role=, CSS selectors, or IDs - Add appropriate waits:
page.wait_for_selector()orpage.wait_for_timeout()
Reference Files
- examples/ - Examples showing common patterns:
element_discovery.py- Discovering buttons, links, and inputs on a pagestatic_html_automation.py- Using file:// URLs for local HTMLconsole_logging.py- Capturing console logs during automation
brand-guidelines
name: brand-guidelines description: Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. license: Complete terms in LICENSE.txt
Anthropic Brand Styling
Overview
To access Anthropic's official brand identity and style resources, use this skill.
Keywords: branding, corporate identity, visual identity, post-processing, styling, brand colors, typography, Anthropic brand, visual formatting, visual design
Brand Guidelines
Colors
Main Colors:
- Dark:
#141413- Primary text and dark backgrounds - Light:
#faf9f5- Light backgrounds and text on dark - Mid Gray:
#b0aea5- Secondary elements - Light Gray:
#e8e6dc- Subtle backgrounds
Accent Colors:
- Orange:
#d97757- Primary accent - Blue:
#6a9bcc- Secondary accent - Green:
#788c5d- Tertiary accent
Typography
- Headings: Poppins (with Arial fallback)
- Body Text: Lora (with Georgia fallback)
- Note: Fonts should be pre-installed in your environment for best results
Features
Smart Font Application
- Applies Poppins font to headings (24pt and larger)
- Applies Lora font to body text
- Automatically falls back to Arial/Georgia if custom fonts unavailable
- Preserves readability across all systems
Text Styling
- Headings (24pt+): Poppins font
- Body text: Lora font
- Smart color selection based on background
- Preserves text hierarchy and formatting
Shape and Accent Colors
- Non-text shapes use accent colors
- Cycles through orange, blue, and green accents
- Maintains visual interest while staying on-brand
Technical Details
Font Management
- Uses system-installed Poppins and Lora fonts when available
- Provides automatic fallback to Arial (headings) and Georgia (body)
- No font installation required - works with existing system fonts
- For best results, pre-install Poppins and Lora fonts in your environment
Color Application
- Uses RGB color values for precise brand matching
- Applied via python-pptx's RGBColor class
- Maintains color fidelity across different systems
competitive-ads-extractor
name: competitive-ads-extractor description: Extracts and analyzes competitors' ads from ad libraries (Facebook, LinkedIn, etc.) to understand what messaging, problems, and creative approaches are working. Helps inspire and improve your own ad campaigns.
Competitive Ads Extractor
This skill extracts your competitors' ads from ad libraries and analyzes what's working—the problems they're highlighting, use cases they're targeting, and copy/creative that's resonating.
When to Use This Skill
- Researching competitor ad strategies
- Finding inspiration for your own ads
- Understanding market positioning
- Identifying successful ad patterns
- Analyzing messaging that works
- Discovering new use cases or pain points
- Planning ad campaigns with proven concepts
What This Skill Does
- Extracts Ads: Scrapes ads from Facebook Ad Library, LinkedIn, etc.
- Captures Screenshots: Saves visual copies of all ads
- Analyzes Messaging: Identifies problems, use cases, and value props
- Categorizes Ads: Groups by theme, audience, or format
- Identifies Patterns: Finds common successful approaches
- Provides Insights: Explains why certain ads likely perform well
How to Use
Basic Extraction
Extract all current ads from [Competitor Name] on Facebook Ad Library
Scrape ads from [Company] and analyze their messaging
Specific Analysis
Get all ads from [Competitor] focusing on their messaging
about [specific problem]. What pain points are they highlighting?
Competitive Set
Extract ads from these 5 competitors: [list].
Compare their approaches and tell me what's working.
Specific Platform
Get LinkedIn ads from [Competitor] and analyze their
B2B positioning strategy
Example
User: "Extract ads from Notion on Facebook Ad Library and tell me what messaging is working for them."
Process:
Accessing Facebook Ad Library...
Searching for: Notion
Found: 23 active ads
Extracting screenshots...
[████████████████████] 100%
Saved to: competitor-ads/notion/
- ad-001-collaboration.png
- ad-002-productivity.png
- ad-003-templates.png
...
Analyzing messaging...
Output:
# Notion Ad Analysis
## Overview
- Total Ads: 23 active
- Primary Themes: Productivity (35%), Collaboration (30%),
Templates (20%), AI Features (15%)
- Ad Formats: Static images (60%), Video (40%)
- CTA Patterns: "Try for free", "Get started"
## Key Problems They're Highlighting
1. **Scattered Information** (8 ads)
Copy: "Stop switching between 10 different tools"
Why it works: Direct pain point many teams face
2. **Meeting Overload** (5 ads)
Copy: "Replace unnecessary meetings with async updates"
Why it works: Post-COVID remote work pain point
3. **Lost Documentation** (4 ads)
Copy: "Never ask 'where is that doc?' again"
Why it works: Universal workplace frustration
## Successful Creative Patterns
### Pattern 1: Before/After Split
- Shows chaotic tool landscape → Clean Notion workspace
- Used in 6 high-performing ads
- Visual metaphor is immediately clear
### Pattern 2: Feature Showcase
- GIF of actual product usage
- Shows specific feature in 5 seconds
- Used for new features (AI, templates)
### Pattern 3: Social Proof
- "Join 20M users" messaging
- Customer logos
- Used in 4 ads targeting enterprise
## Copy That's Working
Best Headlines:
1. "Your team's knowledge, finally in one place"
→ Benefit-focused, addresses pain directly
2. "The all-in-one workspace"
→ Clear positioning, broad appeal
3. "AI that actually helps you work"
→ Addresses AI skepticism, practical angle
Best Body Copy Patterns:
- Short sentences (under 10 words)
- Focus on outcomes not features
- Include specific numbers ("Cut meetings by 50%")
## Audience Targeting Insights
Based on ad variations:
- Startup founders: Solo productivity angle
- Team leads: Collaboration and alignment
- Enterprise: Security and compliance mentions
- Students: Free plan, templates, organization
## Recommendations for Your Ads
1. **Test the "tool sprawl" pain point**
→ Strong resonance based on their ad frequency
2. **Use product screenshots over abstract visuals**
→ All their top ads show actual UI
3. **Lead with the problem, not the solution**
→ "Tired of X?" performs better than "Introducing Y"
4. **Keep copy under 100 characters**
→ Their shortest ads seem most frequent
5. **Test before/after visual formats**
→ Proven pattern in their creative
## Files Saved
- All ads: ~/competitor-ads/notion/
- Analysis: ~/competitor-ads/notion/analysis.md
- Best performers: ~/competitor-ads/notion/top-10/
Inspired by: Sumant Subrahmanya's use case from Lenny's Newsletter
What You Can Learn
Messaging Analysis
- What problems they emphasize
- How they position against competition
- Value propositions that resonate
- Target audience segments
Creative Patterns
- Visual styles that work
- Video vs. static image performance
- Color schemes and branding
- Layout patterns
Copy Formulas
- Headline structures
- Call-to-action patterns
- Length and tone
- Emotional triggers
Campaign Strategy
- Seasonal campaigns
- Product launch approaches
- Feature announcement tactics
- Retargeting patterns
Best Practices
Legal & Ethical
✓ Only use for research and inspiration ✓ Don't copy ads directly ✓ Respect intellectual property ✓ Use insights to inform original creative ✗ Don't plagiarize copy or steal designs
Analysis Tips
- Look for patterns: What themes repeat?
- Track over time: Save ads monthly to see evolution
- Test hypotheses: Adapt successful patterns for your brand
- Segment by audience: Different messages for different targets
- Compare platforms: LinkedIn vs Facebook messaging differs
Advanced Features
Trend Tracking
Compare [Competitor]'s ads from Q1 vs Q2.
What messaging has changed?
Multi-Competitor Analysis
Extract ads from [Company A], [Company B], [Company C].
What are the common patterns? Where do they differ?
Industry Benchmarks
Show me ad patterns across the top 10 project management
tools. What problems do they all focus on?
Format Analysis
Analyze video ads vs static image ads from [Competitor].
Which gets more engagement? (if data available)
Common Workflows
Ad Campaign Planning
- Extract competitor ads
- Identify successful patterns
- Note gaps in their messaging
- Brainstorm unique angles
- Draft test ad variations
Positioning Research
- Get ads from 5 competitors
- Map their positioning
- Find underserved angles
- Develop differentiated messaging
- Test against their approaches
Creative Inspiration
- Extract ads by theme
- Analyze visual patterns
- Note color and layout trends
- Adapt successful patterns
- Create original v
…
Related Skills
- SkillsPublic repository for Agent SkillsAI/MLView Details
- Agent SkillsProduction-grade engineering skills for AI coding agents.AI/MLView Details
- Claude Code Best Practicefrom vibe coding to agentic engineering - practice makes claude perfectAI/MLView Details
- Cherry StudioAI productivity studio with smart chat, autonomous agents, and 300+ assistants. Unified access to frontier LLMsAI/MLView Details