Agent Skills Collection

A collection of AI agent skills following the Agent Skills open format. These skills extend AI coding agents with specialized capabilities and domain knowledge.

Available Skills

Curated Skills

Skill	Description
debug	Comprehensive debugging methodology for finding and fixing bugs
expo	Expo React Native performance optimization guidelines
feature-arch	React feature-based architecture guidelines for scalable applications
msw	MSW (Mock Service Worker) best practices for API mocking in tests
mui-base	MUI Base UI style guidelines for building headless React component libraries
nextjs	Next.js 16 App Router performance optimization guidelines
nuqs	nuqs (type-safe URL query state) best practices for Next.js applications
playwright	Playwright testing best practices for Next.js applications
python	Python 3.11+ performance optimization guidelines
rails-dev	Ruby on Rails performance and maintainability optimization guidelines for building backend APIs..
rails-testing	Ruby on Rails testing best practices for writing effective, maintainable test suites with RSpec
react-hook-form	React Hook Form performance optimization for client-side form validation using useForm,..
react	React 19 performance optimization guidelines for concurrent rendering, Server Components,..
refactor	Code refactoring best practices based on Martin Fowler's catalog and Clean Code principles
restful-hateoas	RESTful API design guidelines following the Richardson Maturity Model through to Level 3..
ruby-optimise	Ruby performance optimization guidelines
ruby-refactor	Ruby refactoring guidelines from community best practices
rust-optimise	Rust performance optimization covering memory allocation, ownership efficiency, data structure..
rust-refactor	Architectural refactoring guide for Rust applications covering type safety, ownership patterns,..
rust	Rust performance optimization guidelines
shadcn	shadcn/ui component library best practices and patterns
skill-authoring	Design and development best practices for Claude Code skills, MCP tools, and AI agent capabilities
tailwind	Tailwind CSS v4 performance optimization and best practices guidelines
tanstack-query	TanStack Query v5 performance optimization for data fetching, caching, mutations, and query patterns
tdd	Test-Driven Development methodology and red-green-refactor workflow
terminal-ui	Terminal User Interface (TUI) performance and UX guidelines for TypeScript applications using..
typescript	This skill should be used when the user asks to "optimize TypeScript performance", "speed up tsc..
ui-design	UI/UX and frontend design best practices guidelines
vitest	Vitest testing framework patterns for test setup, async testing, mocking with vi.*, snapshots,..
zod	Zod schema validation best practices for type safety, parsing, and error handling

Experimental Skills

Skill	Description
12-factor-app	The Twelve-Factor App methodology for building scalable, maintainable cloud-native applications
37signals-rails	37signals Rails coding principles and conventions from DHH, Jorge Manrubia, and the..
ast-grep	ast-grep rule writing and usage best practices
audio-voice-recovery	Audio forensics and voice recovery guidelines for CSI-level audio analysis
chrome-extension-ui	Chrome Extensions UX/UI design and implementation guidelines for popups, side panels, content..
chrome-extension	Chrome Extensions (Manifest V3) performance and code quality guidelines
clean-architecture	Clean Architecture principles and best practices from Robert C
clean-code	Use when writing, reviewing, or refactoring code for maintainability and readability
code-simplifier	Code simplification skill for improving clarity, consistency, and maintainability while..
codemod	Codemod (JSSG, ast-grep, workflows) best practices for writing efficient, safe, and maintainable..
dockerfile-optimise	Dockerfile optimization guidelines from official Docker documentation
emilkowal-animations	Emil Kowalski's animation best practices for web interfaces
expo-react-native-coder	Comprehensive Expo React Native feature development guide
expo-react-native-performance	Expo React Native performance optimization guidelines
feature-spec	Feature specification and planning guidelines for software engineers
framer-motion	Framer Motion performance optimization guidelines
humanize	Remove signs of AI-generated writing from text
ios-animations	Clinic-architecture-aligned iOS animation craft guidelines for SwiftUI (iOS 26 / Swift 6.2)..
ios-chaos-monkey	Crash-hunter skill for iOS 26 / Swift 6.2 clinic-architecture codebases that finds and fixes..
ios-design-system	Clinic-architecture-aligned iOS design system engineering for SwiftUI (iOS 26 / Swift 6.2):..
ios-design	SwiftUI interface implementation patterns aligned with the iOS 26 / Swift 6.2 clinic modular..
ios-hig	Apple Human Interface Guidelines for iOS 26 / Swift 6.2 clinic-architecture apps
ios-navigation	Opinionated SwiftUI navigation enforcement for iOS 26 / Swift 6.2 clinic modular MVVM-C apps
ios-storyboard	Legacy interoperability skill for Storyboard and Interface Builder maintenance in iOS 26 / Swift..
ios-testing	Testing practices for iOS 26 / Swift 6.2 clinic modular MVVM-C applications
ios-ui-refactor	Principal-level SwiftUI UI review and refactoring patterns for iOS 26 / Swift 6.2..
ios-xcode	Xcode setup and tooling guidance for iOS 26 / Swift 6.2 clinic modular MVVM-C projects: project..
js-google	JavaScript style and best practices based on Google's official JavaScript Style Guide
jscodeshift	jscodeshift codemod development best practices from Facebook/Meta
knip-deadcode	Knip dead code detection best practices for JavaScript and TypeScript projects
nginx-c-module-debug	nginx C module debugging guidelines based on the official nginx development guide
nginx-c-module-design	nginx C module directive design guidelines for creating admin-friendly configuration interfaces
nginx-c-module-perf	nginx C module performance optimization and reliability guidelines based on the official nginx..
nginx-c-modules	nginx C module development guidelines based on the official nginx development guide
orval	Orval OpenAPI TypeScript client generation best practices
pulumi	Pulumi infrastructure as code performance and reliability guidelines
rails-application-ui-blocks	Compose new Rails backend pages and refactor existing Rails UI to use premium blocks from..
rails-design-system	Ruby on Rails design system guidelines for building consistent, maintainable UI with minimal..
rails-hotwire	Ruby on Rails Hotwire best practices for building interactive applications with Turbo Drive,..
react-native-elements	React Native Elements UI component library best practices for performance, theming, and proper..
react-optimise	Application-level React performance optimization covering React Compiler mastery, bundle..
react-refactor	Architectural refactoring guide for React applications covering component architecture, state..
react-testing-library	React Testing Library best practices for writing maintainable, user-centric tests
rust-clap	Rust Clap CLI argument parsing best practices
rust-cli-agent-style	Coding patterns extracted from OpenAI Codex Rust codebase - a production CLI/agent system with..
rust-system-event-driven	Rust event-driven system programming best practices for async runtimes, channels, sockets,..
rust-testing	Rust testing patterns for CLI applications, libraries, and frameworks
shell	Shell scripting best practices for writing safe, portable, and maintainable bash/sh scripts
swift-data	SwiftData persistence and data-layer architecture for iOS 26 / Swift 6.2 clinic modular MVVM-C apps
swift-optimise	Swift 6.2 and SwiftUI performance optimization for iOS 26 clinic architecture codebases
swift-refactor	Swift and SwiftUI refactoring patterns aligned with the iOS 26 / Swift 6.2 clinic modular MVVM-C..
swift-ui-architect	Opinionated SwiftUI architecture enforcement for iOS 26 / Swift 6.2 clinic modular MVVM-C apps..
tailwind-refactor	Tailwind CSS code refactoring patterns for v4 migration and anti-pattern cleanup
tailwind-responsive-ui	Responsive UI transformation patterns for Tailwind CSS applications
tailwind-ui-refactor	Refactoring UI design patterns for Tailwind CSS applications
ts-google	Google TypeScript style guide for writing clean, consistent, type-safe code
typescript-refactor	TypeScript refactoring and modernization guidelines from a principal specialist perspective
uniwind	Uniwind best practices for React Native styling with Tailwind CSS
unix-cli	UNIX command-line interface guidelines for building tools that follow POSIX conventions, proper..
vhs	VHS terminal recording best practices from Charmbracelet
vite	Vite performance optimization guidelines
wxt-browser-extensions	WXT browser extension performance optimization guidelines
zustand	Zustand state management best practices for React applications

Installation

Install skills using Vercel's add-skill CLI:

# Install all skills
npx add-skill pproenca/dot-skills

# List available skills
npx add-skill pproenca/dot-skills --list

# Install a specific skill
npx add-skill pproenca/dot-skills --skill <skill-name>

# Install globally (across all projects)
npx add-skill pproenca/dot-skills --global

Supported Agents

Skills are installed to agent-specific directories:

Agent	Installation Path
Claude Code	`.claude/skills/<name>/`
Cursor	`.cursor/skills/<name>/`
Codex	`.codex/skills/<name>/`
OpenCode	`.opencode/skill/<name>/`
Antigravity	`.agent/skills/<name>/`

Creating Skills

See CONTRIBUTING.md for guidelines on creating new skills.

Quick Start

Copy the template: cp -r skills/.template skills/my-skill
Rename the template file: mv skills/my-skill/SKILL.md.template skills/my-skill/SKILL.md
Edit SKILL.md with your skill's frontmatter and instructions
Add scripts, references, or assets as needed
Test with npx add-skill . --list

Skill Structure

skills/
├── my-skill/
│   ├── SKILL.md          # Required: Skill definition and instructions
│   ├── scripts/          # Optional: Executable scripts
│   ├── references/       # Optional: Additional documentation
│   └── assets/           # Optional: Static resources
├── .curated/             # Vetted, production-ready skills
├── .experimental/        # Work-in-progress skills
└── .template/            # Skill template (SKILL.md.template)

License

MIT

Name	rust-idioms
Description	Rust refactoring and idiomatic patterns guidelines from the Rust Community (formerly rust-refactor). This skill should be used when writing, reviewing, or refactoring Rust code to ensure idiomatic patterns and clean architecture. Triggers on tasks involving Rust types, ownership, error handling, traits, modules, conversions, or iterator patterns.

rust-idioms

SKILL.md