Template Skill
- 10 installs
- Updated November 18, 2025
- wesley1600/claudecodeframework
Helps with ai & agent building tasks.
About
template-skill is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted coding.
- template-skill
- AI & Agent Building
- AI-coding skill
Template Skill by the numbers
- 10 all-time installs (skills.sh)
- Ranked #11,937 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
- Data as of Jul 27, 2026 (Skillselion catalog sync)
npx skills add https://github.com/wesley1600/claudecodeframework --skill template-skillAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 10 |
|---|---|
| Last updated | November 18, 2025 |
| Repository | wesley1600/claudecodeframework ↗ |
What it does
Helps with ai & agent building tasks.
Files
Template Skill
This is a starter template for building your own Claude Skills. Use this as a foundation for creating custom tools that extend Claude's capabilities.
Purpose
This skill demonstrates the proper structure and format for Claude Skills, including:
- YAML frontmatter with required metadata
- Clear instructions and guidelines
- Example usage patterns
- Helper scripts and resources
- Best practices for skill development
When to Use
Use this skill as a reference when:
- Creating a new custom skill for your workflow
- Learning about skill structure and organization
- Understanding how to bundle resources and documentation
- Building skills for team collaboration
Key Features
1. Well-Organized Structure - Follows the recommended directory layout with clear separation of concerns 2. Progressive Disclosure - Bundles helper scripts and documentation that Claude loads as needed 3. Example Usage - Provides concrete examples of how the skill should be invoked 4. Flexible and Extensible - Easily customize for your specific use case
Directory Structure
template-skill/
├── SKILL.md # Main skill definition (this file)
├── scripts/
│ ├── helper.py # Python helper script
│ └── utilities.sh # Bash utilities
├── references/
│ └── best-practices.md # Supporting documentation
└── assets/
├── templates/ # Template files
└── examples/ # Example dataInstructions
When you activate this skill, Claude will:
1. Follow the guidelines outlined below 2. Use helper scripts from the scripts/ directory when appropriate 3. Reference documentation from the references/ directory for detailed information 4. Apply templates from the assets/ directory to structure outputs 5. Provide clear examples based on the patterns demonstrated here
Guidelines
- Keep your SKILL.md file concise (under 5,000 words) to avoid overwhelming Claude's context window
- Use progressive disclosure - provide basic instructions in SKILL.md and detailed docs in separate files
- Include concrete examples and expected outputs to clarify your intent
- Organize helper files logically in subdirectories (scripts/, references/, assets/)
- Document any dependencies or prerequisites clearly
- Make skills modular and composable with other skills
Examples
Example 1: Basic Invocation
When you want to use this skill, simply activate it and describe your task:
Activate the template-skill and help me create a new custom skill for handling batch data processing.Example 2: With Specific Parameters
Use the template-skill to generate a skill that integrates with our internal API and follows our team's coding standards.Example 3: Extending the Template
Based on the template-skill structure, help me create a skill that automates our documentation workflow.Helper Resources
This skill includes the following helper files:
- scripts/helper.py - Python utilities for common tasks
- scripts/utilities.sh - Bash functions for file and text processing
- references/best-practices.md - Detailed guidelines for skill development
- assets/templates/ - Ready-to-use templates for common skill patterns
- assets/examples/ - Real-world examples of well-structured skills
Tips for Creating Your Own Skill
1. Start with a clear purpose - Define what problem your skill solves 2. Keep instructions concise - Users should understand your skill in seconds 3. Provide examples - Show concrete use cases and expected outputs 4. Organize resources - Use subdirectories (scripts/, references/, assets/) to stay organized 5. Test thoroughly - Verify that Claude correctly interprets your skill instructions 6. Document dependencies - Clearly list any prerequisites or external tools required 7. Iterate based on feedback - Refine your skill based on how Claude uses it
Related Resources
- Claude Code Documentation: https://docs.claude.com/claude-code/skills
- Skill Authoring Best Practices: https://docs.claude.com/en/docs/agents-and-tools/agent-skills/best-practices
- Anthropic Skills Repository: https://github.com/anthropics/skills
Support
For questions about creating skills or issues with this template: 1. Review the guidelines and examples above 2. Check the supporting documentation in references/best-practices.md 3. Examine the helper scripts in the scripts/ directory 4. Consult the Anthropic skills repository for additional examples
{
"metadata": {
"title": "Example Data Structure",
"description": "This file demonstrates a well-structured JSON example",
"version": "1.0.0",
"author": "Claude Skills Team",
"created": "2024-01-15T10:00:00Z"
},
"users": [
{
"id": "usr_001",
"name": "Alice Johnson",
"email": "alice.johnson@example.com",
"role": "admin",
"active": true,
"created_at": "2024-01-01T09:00:00Z",
"tags": ["lead", "developer", "python"]
},
{
"id": "usr_002",
"name": "Bob Smith",
"email": "bob.smith@example.com",
"role": "contributor",
"active": true,
"created_at": "2024-01-05T14:30:00Z",
"tags": ["developer", "javascript"]
},
{
"id": "usr_003",
"name": "Charlie Brown",
"email": "charlie.brown@example.com",
"role": "viewer",
"active": false,
"created_at": "2024-01-10T11:15:00Z",
"tags": ["analyst"]
}
],
"projects": [
{
"id": "proj_001",
"name": "API Documentation",
"description": "Comprehensive API documentation and examples",
"status": "active",
"owner_id": "usr_001",
"members": ["usr_001", "usr_002"],
"created_at": "2024-01-01T10:00:00Z",
"updated_at": "2024-01-15T15:30:00Z",
"metrics": {
"documentation_coverage": 92,
"test_coverage": 87,
"health_score": 89.5
}
},
{
"id": "proj_002",
"name": "Data Pipeline",
"description": "ETL pipeline for data processing",
"status": "in_progress",
"owner_id": "usr_002",
"members": ["usr_002"],
"created_at": "2024-01-05T12:00:00Z",
"updated_at": "2024-01-14T09:45:00Z",
"metrics": {
"documentation_coverage": 65,
"test_coverage": 72,
"health_score": 68.5
}
}
],
"statistics": {
"total_users": 3,
"active_users": 2,
"total_projects": 2,
"active_projects": 1,
"total_commits": 247,
"lines_of_code": 15420
},
"configuration": {
"enable_notifications": true,
"max_project_size_mb": 1024,
"retention_days": 90,
"backup_enabled": true,
"backup_frequency": "daily"
}
}
[Document Title]
Author: [Your Name] Date: [Date] Version: [Version Number]
---
Table of Contents
1. Introduction 2. Objectives 3. Key Sections 4. Examples 5. Conclusion
Introduction
[Provide a brief overview of the document. Explain the context and relevance.]
Background
[Optional: Provide historical context or background information.]
Objectives
- Objective 1: [Description]
- Objective 2: [Description]
- Objective 3: [Description]
Key Sections
Section 1: [Topic Name]
[Content for this section]
Subsection 1.1: [Subtopic]
[Detailed content]
Key Points:
- Point 1
- Point 2
- Point 3
Section 2: [Topic Name]
[Content for this section]
Section 3: [Topic Name]
[Content for this section]
Examples
Example 1: [Description]
// Code example hereExample 2: [Description]
// Code example hereConclusion
[Summarize the key points and next steps]
---
Related Resources
Appendix
A. Glossary
| Term | Definition |
|---|---|
| [Term 1] | [Definition] |
| [Term 2] | [Definition] |
B. References
- Reference 1
- Reference 2
- Reference 3
Claude Skills - Best Practices Guide
This document provides comprehensive guidelines for creating effective and maintainable Claude Skills.
1. Skill Structure
Directory Organization
Follow this recommended structure:
my-skill/
├── SKILL.md # Core skill definition (required)
├── scripts/ # Helper scripts
│ ├── main.py
│ ├── helpers.py
│ └── setup.sh
├── references/ # Documentation
│ ├── best-practices.md
│ ├── api-reference.md
│ └── troubleshooting.md
├── assets/ # Templates and examples
│ ├── templates/
│ │ ├── default-template.txt
│ │ └── advanced-template.txt
│ └── examples/
│ ├── example-input.json
│ └── example-output.json
└── README.md # Optional: detailed documentationKey Principles
- Single Responsibility: Each skill should have one primary purpose
- Modularity: Design skills to compose well with other skills
- Progressive Disclosure: Keep SKILL.md concise; put detailed docs elsewhere
- Self-Contained: Include all resources needed to operate the skill
2. SKILL.md Format
Required Frontmatter
---
name: skill-name
description: Clear, concise description of what the skill does
---Recommended Sections
1. Skill Name (H1) - Main heading matching the SKILL.md filename 2. Purpose - What problem does this skill solve? 3. When to Use - Specific use cases and scenarios 4. Key Features - What makes this skill useful 5. Instructions - How Claude should behave when using the skill 6. Guidelines - Important rules to follow 7. Examples - Concrete usage patterns 8. Resources - Links to helper files and documentation 9. Support - How to get help or report issues
Example SKILL.md Structure
---
name: my-skill
description: Brief, clear description
---
# My Skill Name
[Keep introduction concise - max 2-3 sentences]
## Purpose
[Explain what problem this solves]
## When to Use
- Use case 1
- Use case 2
- Use case 3
## Key Features
1. Feature 1 - brief description
2. Feature 2 - brief description
3. Feature 3 - brief description
## Instructions
[Clear steps for Claude to follow]
## Guidelines
- Guideline 1
- Guideline 2
- Guideline 3
## Examples
### Example 1
[Show input and expected output]
### Example 2
[Another realistic example]
## Resources
- [Documentation](./references/guide.md)
- [Helper Scripts](./scripts/)
- [Templates](./assets/templates/)
## Support
[How to get help with this skill]3. Content Guidelines
Conciseness
- Keep SKILL.md under 5,000 words to avoid overwhelming Claude's context
- Use clear, direct language
- Remove unnecessary fluff or verbose explanations
- Let helper resources contain detailed information
Clarity
- Use active voice
- Define technical terms on first use
- Include examples for complex concepts
- Organize with clear headers and bullet points
Specificity
- Provide concrete examples with inputs and outputs
- Be explicit about expected behavior
- Highlight edge cases and limitations
- Specify any prerequisites or dependencies
4. Helper Scripts Best Practices
Python Scripts
- Add docstrings to all functions
- Use type hints for function parameters and returns
- Handle errors gracefully with informative messages
- Follow PEP 8 style guidelines
- Include a
if __name__ == "__main__":block for testing
Bash Scripts
- Add comments explaining complex logic
- Use meaningful variable names
- Source utilities in a standardized location
- Include error handling
- Make scripts executable (
chmod +x)
Universal
- Document all functions and their parameters
- Provide usage examples
- Handle missing dependencies gracefully
- Log errors clearly for debugging
- Make scripts modular and reusable
5. Examples and Documentation
Example Quality
- Realistic: Use genuine use cases, not artificial scenarios
- Complete: Show input, process, and output
- Varied: Include basic and advanced examples
- Documented: Explain what each example demonstrates
Example Format
### Example: Create a User Profile
**Input:**{ "name": "Alice Johnson", "email": "alice@example.com", "role": "admin" }
**Process:**
1. Validate the input data
2. Generate a profile ID
3. Create database record
**Output:**{ "id": "prof_123abc", "name": "Alice Johnson", "email": "alice@example.com", "role": "admin", "created_at": "2024-01-15T10:30:00Z" }
6. Resource Files
Templates
- Provide ready-to-use templates for common tasks
- Include both minimal and comprehensive examples
- Document template variables and how to customize them
- Name templates clearly:
template-basic.txt,template-advanced.json
References
- Write supporting documentation in separate files
- Focus on detailed information that's too much for SKILL.md
- Link clearly from SKILL.md to relevant references
- Include API documentation, configuration guides, etc.
Assets
- Keep binary files and example data in the
assets/directory - Organize by type:
examples/,templates/,images/, etc. - Document all asset files
- Include sample data for testing
7. Testing Your Skill
Before Publishing
- [ ] SKILL.md frontmatter is correct (name and description)
- [ ] All referenced files exist and are properly formatted
- [ ] Example inputs and outputs are accurate
- [ ] Helper scripts are executable and tested
- [ ] No broken links in documentation
- [ ] Content is concise and clear
- [ ] Guideline are specific and actionable
Testing with Claude
1. Activate the skill 2. Test basic usage patterns from examples 3. Test edge cases and error conditions 4. Verify resource loading works correctly 5. Check that Claude follows all guidelines 6. Validate output format and quality
8. Common Mistakes to Avoid
❌ Too verbose - Keep SKILL.md focused and concise ❌ Unclear instructions - Be specific about expected behavior ❌ Missing examples - Always include concrete use cases ❌ Broken links - Test all references to helper files ❌ No error handling - Anticipate and address common problems ❌ Poor organization - Use consistent structure across skills ❌ Vague guidelines - Make rules specific and actionable ❌ Missing dependencies - Document all prerequisites
9. Version Control
Commit Messages
feat: Add new template for API documentation
- Include headers and parameter documentation
- Add examples for common endpoints
- Update SKILL.md with new template referenceChangelog Format
## [1.2.0] - 2024-01-15
### Added
- New template for API documentation
- Support for OpenAPI 3.1 specifications
### Fixed
- Markdown formatting in examples
- Broken reference links10. Skill Composition
Working with Multiple Skills
Skills can work together when:
- They have complementary purposes
- Output of one feeds into another
- They follow consistent conventions
- They document their interfaces clearly
Design for Composition
- Document input/output formats clearly
- Use standard data formats (JSON, Markdown, CSV)
- Avoid tight coupling between skills
- Make skills idempotent where possible
Resources
#!/usr/bin/env python3
"""
Helper utilities for Claude Skills.
This module provides common functions that can be used across multiple skills
for data processing, file handling, and text manipulation.
"""
import json
import os
from pathlib import Path
from typing import Any, Dict, List, Optional
def load_json(filepath: str) -> Dict[str, Any]:
"""
Load JSON data from a file.
Args:
filepath: Path to the JSON file
Returns:
Parsed JSON data as a dictionary
Raises:
FileNotFoundError: If the file doesn't exist
json.JSONDecodeError: If the file isn't valid JSON
"""
with open(filepath, 'r') as f:
return json.load(f)
def save_json(data: Dict[str, Any], filepath: str, indent: int = 2) -> None:
"""
Save data to a JSON file.
Args:
data: Dictionary to save
filepath: Path where to save the JSON file
indent: JSON indentation level (default: 2)
"""
Path(filepath).parent.mkdir(parents=True, exist_ok=True)
with open(filepath, 'w') as f:
json.dump(data, f, indent=indent)
def format_markdown_table(headers: List[str], rows: List[List[str]]) -> str:
"""
Generate a markdown table from headers and rows.
Args:
headers: List of column headers
rows: List of rows, where each row is a list of cell values
Returns:
Formatted markdown table as a string
Example:
>>> headers = ["Name", "Age", "City"]
>>> rows = [["Alice", "30", "NYC"], ["Bob", "25", "LA"]]
>>> print(format_markdown_table(headers, rows))
| Name | Age | City |
|-------|-----|------|
| Alice | 30 | NYC |
| Bob | 25 | LA |
"""
# Determine column widths
col_widths = [len(h) for h in headers]
for row in rows:
for i, cell in enumerate(row):
col_widths[i] = max(col_widths[i], len(str(cell)))
# Build the table
lines = []
# Header row
header_row = "| " + " | ".join(
str(h).ljust(col_widths[i]) for i, h in enumerate(headers)
) + " |"
lines.append(header_row)
# Separator row
separator = "| " + " | ".join(
"-" * col_widths[i] for i in range(len(headers))
) + " |"
lines.append(separator)
# Data rows
for row in rows:
data_row = "| " + " | ".join(
str(row[i]).ljust(col_widths[i]) for i in range(len(headers))
) + " |"
lines.append(data_row)
return "\n".join(lines)
def read_file(filepath: str) -> str:
"""
Read the contents of a text file.
Args:
filepath: Path to the file
Returns:
File contents as a string
"""
with open(filepath, 'r') as f:
return f.read()
def write_file(filepath: str, content: str) -> None:
"""
Write content to a text file.
Args:
filepath: Path to the file
content: Content to write
"""
Path(filepath).parent.mkdir(parents=True, exist_ok=True)
with open(filepath, 'w') as f:
f.write(content)
def batch_process(items: List[str], process_fn, batch_size: int = 10) -> List[Any]:
"""
Process a list of items in batches.
Args:
items: List of items to process
process_fn: Function to apply to each item
batch_size: Number of items to process per batch
Returns:
List of processed results
"""
results = []
for i in range(0, len(items), batch_size):
batch = items[i : i + batch_size]
for item in batch:
results.append(process_fn(item))
return results
#!/bin/bash
# Bash utilities for Claude Skills
# Color codes for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Log functions with colored output
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_warn() {
echo -e "${YELLOW}[WARN]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1" >&2
}
# Check if a file exists
file_exists() {
if [ -f "$1" ]; then
return 0
else
return 1
fi
}
# Check if a directory exists
dir_exists() {
if [ -d "$1" ]; then
return 0
else
return 1
fi
}
# Create a directory if it doesn't exist
ensure_dir() {
if ! dir_exists "$1"; then
mkdir -p "$1"
log_success "Created directory: $1"
fi
}
# Count lines in a file
count_lines() {
if file_exists "$1"; then
wc -l < "$1"
else
log_error "File not found: $1"
return 1
fi
}
# Get file size in human-readable format
get_file_size() {
if file_exists "$1"; then
du -h "$1" | cut -f1
else
log_error "File not found: $1"
return 1
fi
}
# Search for a pattern in files
search_pattern() {
local pattern=$1
local directory=${2:-.}
if command -v rg &> /dev/null; then
rg "$pattern" "$directory"
elif command -v grep &> /dev/null; then
grep -r "$pattern" "$directory"
else
log_error "Neither rg nor grep found"
return 1
fi
}
# Create a backup of a file
backup_file() {
local file=$1
local timestamp=$(date +%Y%m%d_%H%M%S)
local backup="${file}.backup.${timestamp}"
if file_exists "$file"; then
cp "$file" "$backup"
log_success "Created backup: $backup"
else
log_error "File not found: $file"
return 1
fi
}
# Count files in a directory
count_files() {
local directory=${1:-.}
if dir_exists "$directory"; then
find "$directory" -type f | wc -l
else
log_error "Directory not found: $directory"
return 1
fi
}
# List files with specific extension
list_by_extension() {
local extension=$1
local directory=${2:-.}
if dir_exists "$directory"; then
find "$directory" -type f -name "*.$extension"
else
log_error "Directory not found: $directory"
return 1
fi
}
# Export functions for use in other scripts
export -f log_info
export -f log_success
export -f log_warn
export -f log_error
export -f file_exists
export -f dir_exists
export -f ensure_dir
Related skills
Setup Matt Pocock SkillsScaffold the per-repo configuration that Matt Pocock’s engineering agent skills rely on so they understand the issue tracker, triage labels, and domain documentation la495k196k
Lark AppsConnect Claude, Cursor or custom agents directly to Lark (Feishu) for messaging, document automation, approval workflows and enterprise data access.402k
CavemanSlash token usage by roughly 75% while keeping every technical detail intact when working with Claude Code, Cursor or similar agents.391k94.7k
Lark Skill MakerQuickly turn any Lark/Feishu OpenAPI call or multi-step workflow into a reusable agent skill with its own SKILL.md.386k16k
Running Claude Code Via Litellm CopilotRun Claude Code at a fraction of the cost by routing requests through LiteLLM to the GitHub Copilot Chat API.270k72
Codex PetGenerate a complete Codex Pet spritesheet and metadata from one reference image without needing an OpenAI key or Codex Pro.246k10