AI Agent Skills Hero

🧠 Agent Skills Repository

🆕 NEW: Honest Agent Skill

Just added! A universal skill that configures ALL your AI coding agents to be honest, objective, and non-sycophantic. Run it once, and every agent (Claude Code, GitHub Copilot, Cursor, Windsurf, etc.) will stop telling you what you want to hear and start giving you honest, direct feedback.

🔗 View the Honest Agent Skill →

What it does:

Configures honest, objective communication across 7 verified AI coding agents
One-time setup that updates all your agent instruction files
Supports both project-level and global configuration
Works with Claude Code, Copilot, Cursor, Windsurf, Cline, Aider, and Continue.dev

A curated collection of AI agent skills for enhanced coding assistance

Supercharge your AI coding agents with specialized knowledge and production-ready patterns

Skills • Quick Start • Usage • Contributing

👤 Author

Yuval Avidani

AI Builder & Speaker | GitHub Star ⭐ | AWS GenAI Superstar 🌟

Building the future with AI agents, automation, and cutting-edge technology.
20+ years turning complex ideas into production-ready solutions.

🎤 Speaker & Enterprise AI Trainer
🏆 Recognized for open-source contributions

🤖 This repository was created by Yuval Avidani using GitHub Copilot via VS Code Insiders — demonstrating the power of AI-assisted development!

✨ What Are Agent Skills?

Agent skills are specialized knowledge modules that enhance AI coding agents with domain-specific expertise. They provide:

🎯 Focused Knowledge — Only what the AI doesn't already know
📝 Production-Ready Code — Working examples, not abstract concepts
⚡ Quick Activation — Trigger keywords for instant context
🔄 Reusable Patterns — Copy once, use everywhere

�️ Understanding Agent Skills (Open Standard)

What is SKILL.md?

SKILL.md is a simple, open format for giving AI agents new capabilities and expertise. It's an open standard that works across multiple AI coding agents and platforms.

Agent Skills are folders of instructions, scripts, and resources that your AI agent can discover and use to perform tasks more accurately and efficiently.

Why Use Agent Skills?

For You (Developer):

📚 Learn Faster — Pre-built knowledge from experts in your domain
🎯 Better Results — Agents have context to work more accurately
♻️ Reuse Everywhere — Same skill works across Copilot, Claude Code, Cursor, Windsurf, and more
🔐 Version Control — Skills are part of your repository, tracked in git

For Your Team:

📖 Capture Knowledge — Document processes and best practices
🚀 Share Skills — Distribute expertise across projects
🏢 Enterprise Use — Centralize organizational knowledge

For AI Agents:

🧠 Domain Expertise — Perform specialized tasks reliably
🔧 New Capabilities — Enable new workflows and automations
🎓 Context — Access procedures, scripts, and examples on demand

What Can You Do With Agent Skills?

Agent skills enable AI agents to:

Domain Expertise: Package specialized knowledge (legal review, data analysis, deployment procedures)
New Capabilities: Create presentations, build MCP servers, analyze datasets, debug failures
Repeatable Workflows: Turn multi-step tasks into consistent, auditable processes
Interoperability: Reuse skills across different compatible agent products

📚 How Agent Skills Work (Step-by-Step for Beginners)

Step 1: Understanding the File Structure

Each skill is a simple folder with a SKILL.md file inside:

your-project/
├── .github/skills/          # GitHub Copilot project skills location
│   └── my-skill-name/
│       ├── SKILL.md         # Main skill file (required)
│       ├── script.js        # Optional: supporting scripts
│       └── examples.md      # Optional: more examples
├── .claude/skills/          # Claude Code project skills location
│   └── my-skill-name/
│       └── SKILL.md
└── ~/.copilot/skills/       # Personal skills (available across all projects)
    └── my-skill-name/
        └── SKILL.md

Step 2: Understanding SKILL.md Format

Every SKILL.md file has two parts:

YAML Frontmatter (metadata):

---
name: my-skill-name           # Unique identifier (lowercase, hyphens for spaces)
description: What this skill  # When should the agent use this skill?
license: MIT                  # Optional: license information
---

Markdown Body (instructions): The rest of the file contains instructions and examples for the AI agent.

Step 3: A Real Example

Here's what a simple SKILL.md looks like:

---
name: github-actions-debugging
description: Guide for debugging failing GitHub Actions workflows. Use this when asked to debug CI/CD failures or workflow issues.
---

# Debugging GitHub Actions Workflows

When debugging a failing workflow:

1. **Check the job logs** - Look for error messages and stack traces
2. **Review recent changes** - What changed since the last successful run?
3. **Test locally** - Reproduce the issue in your local environment
4. **Fix and validate** - Make changes and verify they work

## Common Issues and Solutions

### Issue: Workflow fails with "Command not found"
**Solution**: Install the required tool in your workflow step

### Issue: Permission denied when running scripts
**Solution**: Add `chmod +x script.sh` before running the script

Step 4: Agent Discovers and Uses Your Skill

When you ask your AI agent to do something:

"Debug why our GitHub Actions workflow is failing"

The agent will:

✅ Recognize that you're asking about GitHub Actions
✅ Find the github-actions-debugging skill in your project
✅ Load the SKILL.md file into its context
✅ Follow the instructions to help you debug

Step 5: Supported Locations

Project Skills (specific to one repository):

your-repo/.github/skills/ — For GitHub Copilot
your-repo/.claude/skills/ — For Claude Code

Personal Skills (available across all projects on your machine):

~/.copilot/skills/ — For GitHub Copilot (Copilot CLI and VS Code)
~/.claude/skills/ — For Claude Code

Organization/Enterprise Skills (coming soon):

Enterprise-level skills support is in development

🤝 Supported AI Agents

Agent Skills work with these AI coding agents:

Agent	Support	Location
GitHub Copilot	✅ Full Support	`.github/skills/` or `~/.copilot/skills/`
Claude Code	✅ Full Support	`.claude/skills/` or `~/.claude/skills/`
Cursor	✅ Full Support	`.cursor/rules/`
Windsurf	✅ Full Support	`.windsurf/rules/`
VS Code Insiders	✅ Full Support	Agent mode with skills
VS Code (Stable)	⏳ Coming Soon	Support coming in future release

📦 Available Skills

Skill	Description	Keywords
copilot-sdk	GitHub Copilot SDK for building agentic applications	`Copilot SDK`, `GitHub SDK`, `agentic app`, `embed Copilot`
honest-agent 🆕	Configure all AI agents for honest, objective feedback	`honest agent`, `no sycophancy`, `objective`, `contradict me`
aws-agentcore	AWS Bedrock AgentCore development patterns	`AgentCore`, `Bedrock Agent`, `AWS agent`
aws-strands	Model-agnostic agent framework with Strands SDK	`Strands`, `ReAct agent`, `model-agnostic`
aws-account-management	AWS Organizations, IAM, billing & multi-account	`AWS Organizations`, `IAM`, `SCPs`, `Cost Explorer`
langchain	LangChain/LangGraph pipelines and agent workflows	`LangChain`, `LangGraph`, `RAG`, `LCEL`
vercel	Vercel deployment, serverless, and edge functions	`Vercel`, `serverless`, `edge function`
railway	Railway platform deployment and configuration	`Railway`, `deploy container`
cloudflare	Cloudflare Workers, Pages, D1, R2, KV & AI	`Cloudflare`, `Workers`, `D1`, `R2`, `edge computing`
figma	Figma API, component code generation & design tokens	`Figma API`, `design tokens`, `Figma to code`
fal-ai	Serverless AI image/video generation with fal.ai	`fal.ai`, `Flux`, `SDXL`, `AI image generation`
mongodb	MongoDB & Mongoose queries, aggregation pipelines	`MongoDB`, `Mongoose`, `aggregation`, `NoSQL`
bun	Bun JavaScript runtime, bundler & test runner	`Bun`, `bun.sh`, `JavaScript runtime`
owasp-security	OWASP Top 10 security vulnerabilities & prevention	`OWASP`, `security`, `XSS`, `SQL injection`, `CSRF`
shabbat-times	Jewish calendar data and Shabbat times integration	`Shabbat times`, `Hebcal`, `Zmanim`
copilot-docs	GitHub Copilot custom instructions reference	`copilot-instructions.md`
nano-banana-pro	Google Gemini 3 Pro Image generation	`Nano Banana Pro`, `Gemini 3 Pro Image`
github-trending	GitHub trending repositories scraping	`GitHub trending`, `trending repos`
ux-design-systems	Design systems and component libraries	`design system`, `design tokens`, `theming`
web-accessibility	WCAG compliance and accessibility patterns	`accessibility`, `a11y`, `WCAG`, `ARIA`
mobile-responsiveness	Responsive design and mobile-first patterns	`responsive`, `mobile-first`, `breakpoints`
analytics-metrics	Data visualization and analytics dashboards	`analytics`, `dashboard`, `charts`, `KPI`
mermaid-diagrams	Mermaid diagram syntax for visualizations	`Mermaid`, `flowchart`, `sequence diagram`
local-llm-router	Route queries to local LLMs in air-gapped networks with Serena MCP	`local LLM`, `Ollama`, `LM Studio`, `air-gapped`, `Serena`, `model routing`

🚀 Quick Start

1. Clone the Repository

git clone https://github.com/yuval-avidani/ai-agents-skills.git

2. Copy Skills to Your Project

Choose your AI coding agent and follow the instructions below.

💻 Setup Guide: Using Skills in Your Agent (For Beginners)

This guide walks you through setting up Agent Skills in your favorite coding agent, step by step.

🎯 Prerequisites

Before you start, you need:

A coding agent installed (Copilot, Claude Code, Cursor, or Windsurf)
A project folder on your computer
Basic familiarity with command line or your agent's UI

📍 Step-by-Step Setup

Option 1: GitHub Copilot (Most Popular)

🟢 Setup GitHub Copilot with Skills

For Project Skills (specific to one repository):

In your project folder, create the skills directory:
```
mkdir -p .github/skills
```

Copy the skills you want from this repository:

# Copy a single skill
cp -r skills/vercel .github/skills/

# Or copy all skills
cp -r skills/* .github/skills/

Or manually create a skill:

your-project/
└── .github/
    └── skills/
        └── my-custom-skill/
            └── SKILL.md

Open your project in VS Code and start using Copilot Agent
Ask Copilot a question related to your skill, and it will automatically load it!

For Personal Skills (available across all your projects):

Find your home directory (~ or C:\Users\YourUsername)
Create personal skills folder:
```
mkdir -p ~/.copilot/skills
```
Copy skills there:
```
cp -r skills/vercel ~/.copilot/skills/
```
Now all your projects can use these skills automatically!

Verify it's working:

Open Copilot Agent
Ask about something covered in your skill (e.g., "How do I deploy to Vercel?")
Copilot will use the skill to help you

Option 2: Claude Code

🟣 Setup Claude Code with Skills

For Project Skills:

In your project folder, create the skills directory:
```
mkdir -p .claude/skills
```

Copy the skills you want:

# Single skill
cp -r skills/langchain .claude/skills/

# All skills
cp -r skills/* .claude/skills/

Open your project in Claude Code
Chat with Claude about tasks covered in your skills - it will automatically use them!

For Personal Skills (available everywhere):

Create personal skills folder:
```
mkdir -p ~/.claude/skills
```

Copy skills there:

cp -r skills/aws-agentcore ~/.claude/skills/

Verify it's working:

Open Claude Code in your project
Ask about something in your skill
Claude will reference and use the skill

Option 3: Cursor

🔵 Setup Cursor with Skills

For Project Rules:

In your project folder:
```
mkdir -p .cursor/rules
```

Copy SKILL.md files (rename them as rules):

# Copy a skill as a rule file
cp skills/figma/SKILL.md .cursor/rules/figma.md

# Or copy multiple
cp skills/*/SKILL.md .cursor/rules/

In Cursor Settings, configure which rules to use:
- Settings → Rules → Add project rules
- Point to .cursor/rules/ folder
Start using Cursor - it will apply these rules to your context automatically

Option 4: Windsurf

🟡 Setup Windsurf with Skills

For Project Rules:

In your project folder:
```
mkdir -p .windsurf/rules
```

Copy skills as rules:

# Copy specific skills
cp skills/vercel/SKILL.md .windsurf/rules/vercel.md

# Or copy all skills
cp skills/*/SKILL.md .windsurf/rules/

Windsurf automatically discovers rules in .windsurf/rules/
Start building - Windsurf will use these rules contextually

🎓 What Happens After Setup?

Once you've set up your skills:

Agent Detects Skills: Your AI agent scans the skill directories
Agent Reads SKILL.md: It reads the name and description from frontmatter
Agent Activates on Relevance: When you ask a question matching the description, the agent loads the skill
Agent Follows Instructions: Your agent now has the context to help you accurately

💡 Example: Using a Vercel Skill

You have this SKILL.md:

---
name: vercel-deployment
description: Deploying applications to Vercel. Use this when asked about deploying, hosting, or managing Vercel projects.
---

You ask your agent:

"Help me deploy my React app to Vercel"

Agent automatically:

✅ Finds vercel-deployment skill
✅ Loads SKILL.md into context
✅ Follows the deployment instructions
✅ Helps you deploy successfully!

🐛 Troubleshooting

Problem	Solution
Agent not using skill	Restart your agent, or make sure folder path is correct
Skill file not found	Verify `SKILL.md` is in the right folder and named exactly "SKILL.md"
Agent using wrong skill	Make sure skill descriptions are descriptive enough to match your request

💻 Usage (Advanced)

📐 Skill Format

Each skill follows a consistent structure:

---
name: skill-name
description: Brief description with trigger keywords
---

# Skill Title

Quick start and core patterns...

🎯 Key Principles

Principle	Description
Concise is key	Only include what the AI doesn't already know
Progressive disclosure	Start with quick start, then advanced patterns
Concrete examples	Working code over abstract descriptions
Trigger keywords	Include words that activate the skill

📁 Repository Structure

ai-agents-skills/
├── 📄 README.md
├── 📁 skills/
│   ├── 📁 copilot-sdk/
│   │   └── 📄 SKILL.md
│   ├── 📁 honest-agent/       # 🆕 NEW!
│   │   └── 📄 SKILL.md
│   ├── 📁 aws-agentcore/
│   │   └── 📄 SKILL.md
│   ├── 📁 aws-strands/
│   │   └── 📄 SKILL.md
│   ├── 📁 aws-account-management/
│   │   └── 📄 SKILL.md
│   ├── 📁 langchain/
│   │   └── 📄 SKILL.md
│   ├── 📁 vercel/
│   │   └── 📄 SKILL.md
│   ├── 📁 railway/
│   │   └── 📄 SKILL.md
│   ├── 📁 cloudflare/
│   │   └── 📄 SKILL.md
│   ├── 📁 figma/
│   │   └── 📄 SKILL.md
│   ├── 📁 fal-ai/
│   │   └── 📄 SKILL.md
│   ├── 📁 mongodb/
│   │   └── 📄 SKILL.md
│   ├── 📁 bun/
│   │   └── 📄 SKILL.md
│   ├── 📁 owasp-security/
│   │   └── 📄 SKILL.md
│   ├── 📁 shabbat-times/
│   │   └── 📄 SKILL.md
│   ├── 📁 copilot-docs/
│   │   └── 📄 SKILL.md
│   ├── 📁 nano-banana-pro/
│   │   └── 📄 SKILL.md
│   ├── 📁 github-trending/
│   │   └── 📄 SKILL.md
│   ├── 📁 ux-design-systems/
│   │   └── 📄 SKILL.md
│   ├── 📁 web-accessibility/
│   │   └── 📄 SKILL.md
│   ├── 📁 mobile-responsiveness/
│   │   └── 📄 SKILL.md
│   ├── 📁 analytics-metrics/
│   │   └── 📄 SKILL.md
│   ├── 📁 mermaid-diagrams/
│   │   └── 📄 SKILL.md
│   └── 📁 local-llm-router/
│       ├── 📄 SKILL.md
│       └── 📁 references/
│           └── 📄 model-matrix.md
└── 📁 templates/
    └── 📁 skill-template/
        └── 📄 SKILL.md

🤝 Contributing

We welcome contributions! Here's how to add a new skill:

Fork this repository
Create a new skill in skills/your-skill-name/SKILL.md
Follow the skill template
Submit a pull request

Contribution Guidelines

✅ Include practical, production-ready code examples
✅ Add trigger keywords in the description
✅ Test all code snippets before submitting
✅ Keep explanations concise but complete
❌ Don't include basic concepts the AI already knows
❌ Don't use placeholder code or TODOs

🌟 Star History

If you find this repository useful, please consider giving it a ⭐!

📄 License

MIT License — Feel free to use, modify, and distribute.

Made with ❤️ by Yuval Avidani

Building AI agents that matter

AI Agents Skills

AI-Agent Assisted

README