Skills Plugin & Marketplace

A comprehensive plugin and marketplace for Claude Code containing 24 custom skills across engineering, Apple development, product management, design, content, trading, database, QA, educational, and AI architecture domains.

Overview

This repository provides Claude Code with specialized knowledge and workflows through a curated collection of skills. Each skill includes interactive scripts, comprehensive reference materials, and best practices for specific domains.

Use as a Marketplace to browse and select individual skills, or install as a Plugin to get all skills at once.

Skills Index

Quick navigation to all 24 skills organized by category:

AI & Architecture (2 skills)

anthropic-architect - Determine the best Anthropic architecture for your project
anthropic-prompt-engineer - Master Anthropic's prompt engineering techniques

Engineering (5 skills)

openai-prompt-engineer - Generate and improve prompts using best practices for OpenAI GPT-5
git-worktrees - Manage Git worktrees for parallel development
llm-router - Route requests to different LLM providers
engineer-expertise-extractor - Extract engineering expertise from GitHub
engineer-skill-creator - Transform expertise into actionable skills

Apple Development (3 skills)

swift-concurrency - Build, audit, and refactor Swift 6+ concurrency code
swiftui-animation - Advanced SwiftUI animations and Metal shaders
releasing-macos-apps - Create notarized macOS releases with Sparkle updates

Product Management (1 skill)

prd-generator - Generate Product Requirements Documents

Product Marketing (1 skill)

technical-launch-planner - Plan technical product launches

Design (4 skills)

design-brief-generator - Generate comprehensive design briefs
frontend-designer - Build accessible, responsive UIs
apple-hig-designer - Design native iOS apps
book-illustrator - Children's book illustration guide

Content & Writing (2 skills)

content-brief-generator - Generate SEO-optimized content briefs
kids-book-writer - Write engaging children's books

Trading & Finance (1 skill)

trading-plan-generator - Generate trading plans with risk management

Database & Query (1 skill)

query-expert - Master SQL and database queries

QA & Testing (1 skill)

qa-test-planner - Generate test plans and bug reports

Educational & Learning (3 skills)

math-teacher - Interactive math learning with gamification
reading-teacher - Interactive reading teacher for ages 1-10
leetcode-teacher - Technical interview preparation

Skills

AI & Architecture Skills

anthropic-architect

Determine the best Anthropic architecture for your project. Analyze requirements and receive tailored recommendations on the optimal architecture using Skills, Agents, Subagents, Prompts, and SDK primitives based on proven decision rubrics and 2025 best practices.

Key features:

Analyze project requirements and complexity
Recommend optimal architecture (Skills vs Agents vs Prompts vs SDK)
Apply comprehensive decision rubrics
Progressive disclosure design guidance
Security and performance best practices
Real-world architectural patterns
Cost optimization strategies

Usage:

"Using anthropic-architect, determine the best architecture for my code review system"
"Help me choose between Skills and Agents for this workflow"
"Analyze my project and recommend the right Anthropic primitives"
"What's the best architecture for automated testing?"

The Four Anthropic Primitives:

Skills - Reusable domain expertise with progressive disclosure
Agents/Subagents - Autonomous task handlers with isolated contexts
Direct Prompts - Simple, clear instructions for straightforward tasks
SDK Primitives - Custom workflows and system integrations

Decision Framework:

Task Complexity:
  Low (1-3) → Direct Prompts
  Medium (4-6) → Skills
  High (7-9) → Agents/Subagents
  Custom (10) → SDK Primitives

Plus evaluation of:
- Reusability requirements
- Context management needs
- Security & control requirements
- Performance needs
- Maintenance burden
- Time to market

Reference materials:

decision_rubric.md - Comprehensive 7-dimension decision framework
architectural_patterns.md - 14 proven architecture patterns
best_practices.md - 2025 Anthropic best practices (progressive disclosure, context management, security)
use_case_examples.md - Real-world architectures for common use cases

Perfect for:

Choosing the right Anthropic primitives for your project
Designing scalable, maintainable AI architectures
Optimizing context usage and costs
Following 2025 best practices
Avoiding common anti-patterns
Learning when to use Skills vs Agents vs Prompts
Building production-ready AI systems

Example Recommendations:

Use Case: Code Review System

Recommended: Skills + Direct Prompts
Why: Reusable standards (Skills), simple workflow (Prompts)
Pattern: Load code-review-expert skill, review PRs with prompts

Use Case: Full-Stack Feature

Recommended: Specialist Agents + Skills
Why: Complex multi-layer work, parallel execution, specialized expertise
Pattern: Frontend/Backend/DevOps agents each load relevant skills

Use Case: Simple Bug Fix

Recommended: Direct Prompt
Why: One-time task, minimal complexity, no reusability needed
Pattern: Clear instruction to Claude

View anthropic-architect skill →

anthropic-prompt-engineer

Master Anthropic's prompt engineering techniques for Claude AI models. Generate new prompts from scratch or improve existing ones using best practices, XML structuring, chain-of-thought reasoning, and progressive disclosure patterns optimized for Claude 4.x.

Key features:

Generate effective prompts from requirements
Improve existing prompts with proven techniques
Claude-specific optimizations (XML tags, thinking, prefilling)
Apply core techniques: clear instructions, few-shot examples, role assignment
Advanced patterns: progressive disclosure, chain-of-thought, structured output
Avoid common mistakes and hallucinations
Production-ready prompt templates

Usage:

"Using anthropic-prompt-engineer, create a prompt for extracting structured data"
"Improve this prompt using Anthropic best practices"
"Generate a Claude-optimized prompt for code analysis"
"Debug why this prompt gives inconsistent results"

Core Anthropic Techniques:

XML Tags - Structure prompts with semantic tags like <instructions>, <example>, <context>
Chain of Thought - Ask Claude to think step-by-step for complex reasoning
Prefilling - Start Claude's response to guide format and style
Few-Shot Examples - Provide 2-5 diverse examples showing desired pattern
Progressive Disclosure - Load context incrementally to optimize token usage
Clear Instructions - Claude 4.x excels with explicit, unambiguous direction

Reference materials:

core_techniques.md - Essential Anthropic techniques with examples
advanced_techniques.md - Advanced optimization methods
common_mistakes.md - Pitfalls to avoid
claude_4_best_practices.md - Claude 4.x specific guidance
prompt_templates.md - Ready-to-use production templates

Perfect for:

Creating consistent, high-quality prompts for Claude
Learning Anthropic-specific techniques (vs OpenAI/GPT patterns)
Optimizing prompts for Claude 4.x models
Building prompt libraries for your team
Reducing hallucinations and errors
Achieving first-try success more often
Production prompt engineering

Example Improvements:

Before:

"Analyze this code"

After (Anthropic-optimized):

<instructions>
Analyze the code below for:
1. Security vulnerabilities
2. Performance issues
3. Code quality concerns

For each issue found:
- Specify exact line number
- Explain the problem
- Provide specific fix recommendation
</instructions>

<code>
[code here]
</code>

<output_format>
Return JSON array:
[{
  "type": "security|performance|quality",
  "line": number,
  "issue": "description",
  "fix": "recommendation"
}]
</output_format>

View anthropic-prompt-engineer skill →

Engineering Skills

openai-prompt-engineer

Generate and improve prompts using cutting-edge techniques for OpenAI GPT-5 and other LLMs. Apply advanced patterns like chain-of-thought, few-shot prompting, structured output, and progressive disclosure to create effective, consistent prompts.

Key features:

Generate new prompts from specifications
Improve existing prompts with proven techniques
Model-specific optimizations (GPT-5 vs Claude)
Advanced patterns: Chain-of-Thought, Few-Shot, XML structuring
Prompt quality analysis and debugging
Comprehensive best practices library

Usage:

"Using openai-prompt-engineer, create a prompt for code review"
"Improve this prompt for better results"
"Generate a GPT-5 optimized prompt for data analysis"
"Analyze this prompt and suggest improvements"

Techniques covered:

GPT-5 specific: Structured prompting (role+task+constraints), reasoning effort control, agentic behavior calibration, verbosity management
Claude specific: XML tag structuring, step-by-step thinking, progressive disclosure, long-context optimization
Universal: Chain-of-thought prompting, few-shot learning, zero-shot prompting, self-consistency, role-based prompting

Reference materials:

gpt5_techniques.md - GPT-5 specific best practices and patterns
claude_techniques.md - Claude/Anthropic optimization strategies
prompt_patterns.md - Reusable templates for common tasks
optimization_strategies.md - Systematic prompt improvement framework

Perfect for:

Creating consistent, high-quality prompts
Optimizing prompts for specific models
Learning advanced prompting techniques
Reducing API costs through better prompts
Achieving first-try success more often
Building prompt libraries for your team

Example improvements:

Before:

"Write code for authentication"

After (GPT-5 optimized):

ROLE: Senior TypeScript developer
TASK: Implement JWT-based authentication service
REQUIREMENTS:
- TypeScript with strict mode
- Include refresh token rotation
- Comprehensive error handling
- Unit tests with 80%+ coverage
OUTPUT: Complete implementation with tests and usage example

View openai-prompt-engineer skill →

git-worktrees

Manage Git worktrees for parallel Claude Code development. Run multiple Claude Code sessions simultaneously on different branches without conflicts.

Key features:

Super simple scripts for worktree management
Interactive worktree creation and cleanup
Automatic sync with main branch
Best practices and command reference
Custom slash command template

Usage:

"Create a worktree for feature-api"
"List all active worktrees"
"Clean up old worktrees"
"Sync worktree with main branch"

Includes:

create_worktree.sh - Interactive worktree creation
list_worktrees.sh - View all active worktrees
cleanup_worktrees.sh - Remove old worktrees safely
sync_worktree.sh - Keep worktrees up-to-date
Complete command reference and best practices
Custom /worktree slash command template

Perfect for:

Parallel AI development with multiple Claude sessions
Hotfixes during feature development
Code review without context switching
Experimentation without breaking main work

View git-worktrees skill →

llm-router

Route AI requests to different LLM providers using SwiftOpenAI-CLI.

Supported providers:

OpenAI (GPT-4, GPT-5)
Grok (xAI)
Groq (Llama, Mixtral)
DeepSeek
OpenRouter (300+ models)

Usage:

"Use grok to explain quantum computing"
"Ask deepseek to solve this problem"
"Use groq for fast code generation"

View llm-router skill →

engineer-expertise-extractor

🔥 Extract and replicate engineering expertise from GitHub contributions. Research any engineer's coding style, patterns, and best practices to create a structured knowledge base that AI agents can use to code like them.

Key features:

GitHub CLI integration for PR analysis
Automated expertise extraction from code
Structured knowledge organization by topic
Coding style documentation (naming, formatting, structure)
Pattern identification and cataloging
Best practices extraction
Architectural decision documentation
Code review style analysis

Usage:

"Extract expertise from engineer @username"
"Research coding patterns from their PRs"
"Document their architectural decisions"
"Analyze their code review style"
"Create agent training profile"

Includes:

extract_engineer.sh - Full extraction workflow with GitHub CLI
Organized folder structure (coding_style/, patterns/, best_practices/, architecture/)
Template documentation files
PR analysis and pattern recognition
Profile README generation

Output Structure:

engineer_profiles/
└── [username]/
    ├── README.md (profile overview)
    ├── coding_style/ (conventions & preferences)
    ├── patterns/ (common solutions & approaches)
    ├── best_practices/ (quality standards)
    ├── architecture/ (design decisions)
    ├── code_review/ (feedback patterns)
    └── examples/ (real code samples)

Perfect for:

Creating "digital mentors" from senior engineers
Training AI agents to code in specific styles
Onboarding new engineers with real examples
Preserving knowledge before engineers leave
Establishing team coding standards
Code review training materials

Use Cases:

AI Agent Training: "Using engineer_profiles/senior_dev/, write code matching their style"
Knowledge Transfer: Extract expertise before engineer leaves
Team Standards: Create evidence-based coding guidelines
Onboarding: Provide real examples from top engineers

Requirements: GitHub CLI (gh) installed and authenticated

View engineer-expertise-extractor skill →

engineer-skill-creator

Transform extracted expertise into actionable skills with progressive disclosure. Takes engineer profiles from the extractor and creates structured, queryable skills that AI agents can use to find relevant expertise for specific tasks.

Key features:

Progressive disclosure system (show only what's needed)
Task-based organization (authentication, API design, testing, etc.)
Language-specific guidance
Pattern library with examples
Interactive query tool
Quick reference guides
Automatic categorization

Usage:

"Create a skill from engineer profile"
"Transform expertise into queryable format"
"Generate progressive disclosure navigation"
"Package expertise for agent use"

Workflow:

# Step 1: Extract expertise
./extract_engineer.sh senior_dev

# Step 2: Create skill (THIS TOOL)
./create_expert_skill.sh senior_dev

# Step 3: Use with agents
"Using expert-skills/senior-dev-mentor/, implement auth"

Output Structure:

expert-skills/[name]-mentor/
├── SKILL.md (documentation)
├── query_expertise.sh (interactive query)
├── expertise/
│   ├── by_task/ (auth, API, testing, etc.)
│   ├── by_language/ (TypeScript, Python, etc.)
│   ├── by_pattern/ (DI, repository, etc.)
│   └── quick_reference/ (style, naming, etc.)
└── examples/ (real code samples)

Progressive Disclosure:
Instead of dumping all expertise at once, agents query specific needs:

"How do they handle authentication?" → Gets only auth patterns
"TypeScript coding style?" → Gets only TS conventions
"Repository pattern?" → Gets only that pattern

Perfect for:

Making expertise searchable and queryable
Enabling task-specific guidance
Creating AI agent training materials
Building onboarding resources
Scaling knowledge across teams

Use with agents:

"Using expert-skills/senior-dev-mentor/, write a user service
following their patterns and style"

"Using expert-skills/tech-lead-mentor/, review this code using
their standards"

Requirements: Completed engineer profile from engineer-expertise-extractor

The Complete Workflow:

Extract: engineer-expertise-extractor → Creates profile
Create: engineer-skill-creator → Transforms into skill
Use: Reference skill in agent prompts → Get expert guidance

View engineer-skill-creator skill →

Apple Development Skills

swift-concurrency

Build, audit, and refactor Swift code using modern concurrency patterns (Swift 6+). Comprehensive guide for async/await, Tasks, actors, MainActor, Sendable types, isolation domains, and Approachable Concurrency settings.

Key features:

Building workflow with isolation decision trees
Auditing checklist for concurrency issues
Refactoring patterns (callbacks → async/await, DispatchQueue → actors)
Isolated parameters for non-Sendable types
Approachable Concurrency settings (Swift 6.2+)
Common mistakes and anti-patterns

Usage:

"Using swift-concurrency, audit this code for concurrency issues"
"Refactor this callback-based code to async/await"
"Should I use an actor or MainActor here?"
"Fix the Sendable errors in this code"

Three Workflows:

Building: Decision trees for isolation, async function design, parallel work
Auditing: Checklists for critical issues, common mistakes, SwiftUI-specific problems
Refactoring: Migrate callbacks, DispatchQueue, and Combine to modern concurrency

Quick Reference:

Keyword	Purpose
`async`	Function can suspend
`await`	Suspension point
`Task { }`	Start async work, inherits isolation
`@MainActor`	Runs on main thread
`actor`	Type with isolated mutable state
`nonisolated`	Opts out of actor isolation
`@concurrent`	Always run on background (Swift 6.2+)
`Sendable`	Safe to cross isolation boundaries

Reference materials:

fundamentals.md - async/await, Tasks, structured concurrency
isolation.md - Actors, MainActor, isolation domains
sendable.md - Sendable protocol, non-Sendable patterns
common-mistakes.md - Anti-patterns to avoid
glossary.md - Complete terminology reference

Perfect for:

Swift 6 migration
Auditing existing concurrency code
Understanding isolation domains
Fixing Sendable errors
Learning modern Swift concurrency patterns

View swift-concurrency skill →

swiftui-animation

Advanced SwiftUI animations, transitions, and Metal shader integration. Comprehensive guidance for implementing animations, matched geometry effects, and GPU-accelerated visual effects in iOS and macOS apps.

Key features:

Spring animations with iOS 17+ presets
View transitions (opacity, scale, slide, custom)
Matched geometry effect for hero animations
Metal shader integration (colorEffect, distortionEffect, layerEffect)
PhaseAnimator and KeyframeAnimator
HIG Motion design principles

Usage:

"Using swiftui-animation, create a hero animation between views"
"Add a spring animation to this button"
"Implement a Metal shader ripple effect"
"Create an expandable card animation"

Animation Basics:

// Explicit animation (preferred)
withAnimation(.spring(response: 0.4, dampingFraction: 0.75)) {
    isExpanded.toggle()
}

// iOS 17+ spring presets
withAnimation(.snappy) { ... }  // Fast, small bounce
withAnimation(.smooth) { ... }  // Gentle, no bounce
withAnimation(.bouncy) { ... }  // More bounce

Matched Geometry Effect:

@Namespace var namespace

// Source view
ThumbnailView()
    .matchedGeometryEffect(id: "hero", in: namespace)

// Destination view
DetailView()
    .matchedGeometryEffect(id: "hero", in: namespace)

Reference materials:

motion-guidelines.md - HIG Motion design principles
animations.md - Complete animation API guide
transitions.md - View transitions and hero animations
metal-shaders.md - GPU shader integration

Best Practices:

Prefer explicit animations with withAnimation
Use spring animations for natural feel
Start with .spring(response: 0.35, dampingFraction: 0.8)
Keep animations under 400ms
Test on device (simulator timing differs)

Perfect for:

iOS/macOS app developers
SwiftUI animation implementation
Hero transitions between views
Custom Metal shader effects
Polished, Apple-quality interactions

View swiftui-animation skill →

releasing-macos-apps

Create notarized macOS app releases with Sparkle auto-updates, DMG installers, and GitHub releases. Complete workflow for code signing, notarization, and distribution of macOS applications.

Key features:

Step-by-step release checklist
Code signing with Developer ID certificates
Apple notarization (app-specific password & API key methods)
Sparkle framework integration for auto-updates
DMG creation with Applications folder symlink
GitHub release asset management
EdDSA signature generation for Sparkle

Usage:

"Release my macOS app with notarization"
"Create a DMG with Applications folder"
"Set up Sparkle auto-updates"
"Generate Sparkle signature for my app"
"Upload release assets to GitHub"

Includes:

SKILL.md - Complete release workflow with checklist
NOTARIZATION.md - Apple notarization guide (credentials & API keys)
SPARKLE.md - Sparkle framework setup and EdDSA signing
TROUBLESHOOTING.md - Common issues and solutions

Notarization Methods:

App-specific password: Traditional method with Apple ID credentials
API Key: Modern method using App Store Connect API keys (better for CI/CD)

Sparkle Key Storage Options:

File in project (gitignored)
macOS Keychain
Environment variables

Perfect for:

macOS app developers
Independent software vendors
Open source macOS projects
Apps requiring auto-update functionality
GitHub-based distribution workflows

Use with Claude:

"Using releasing-macos-apps, create a notarized release of my app"

"Set up Sparkle auto-updates with EdDSA signing"

"Troubleshoot my notarization failure"

View releasing-macos-apps skill →

Product Management Skills

prd-generator

Generate comprehensive Product Requirements Documents (PRDs) for product managers.

Key features:

Interactive PRD generation workflow
Standard PRD templates (full, lean, one-pager)
User story creation with acceptance criteria
Success metrics frameworks (AARRR, HEART, North Star, OKRs)
PRD validation and completeness checking
Comprehensive reference materials

Usage:

"Create a PRD for user authentication"
"Generate a lean PRD for dark mode feature"
"Write requirements for a new dashboard"
"Help me create user stories for checkout flow"

Includes:

Complete PRD template with all standard sections
User story examples and best practices
Metrics frameworks guide (AARRR, HEART, OKRs)
Interactive generation script
Validation script for quality checking

View prd-generator skill →

Product Marketing Skills

technical-launch-planner

Plan and execute technical product launches for developer tools, APIs, and technical products.

Key features:

Launch tier assessment (Tier 1/2/3 framework)
Interactive launch plan generation
Developer enablement checklists
Technical messaging templates
Launch readiness validation
Post-launch tracking

Usage:

"Plan a launch for our new API"
"Determine the launch tier for this feature"
"Create a developer enablement checklist"
"Generate technical launch messaging"
"Validate launch readiness"

Includes:

assess_launch_tier.sh - Determine appropriate launch tier
generate_launch_plan.sh - Create comprehensive launch plan
validate_readiness.sh - Pre-launch readiness checker
Developer enablement complete checklist
Technical messaging frameworks and templates
Launch tier frameworks (GA, Beta, Preview)

Perfect for:

Developer tools and platforms
API and SDK launches
Technical infrastructure products
B2D (Business-to-Developer) products

View technical-launch-planner skill →

Design Skills

design-brief-generator

Generate comprehensive design briefs for design projects, ensuring alignment and clarity before design work begins.

Key features:

Interactive design brief generation
Complete design brief template with all sections
Accessibility guidelines (WCAG 2.1)
Design principles framework
User research methods guide
Brief validation and completeness checking

Usage:

"Create a design brief for mobile app redesign"
"Generate a brief for new feature design"
"Help me document design requirements"
"Validate my design brief for completeness"
"What accessibility requirements should I include?"

Includes:

generate_brief.sh - Interactive brief generation
validate_brief.sh - Brief completeness validation
Complete design brief template
WCAG 2.1 accessibility guidelines
Design principles creation guide
User research methods reference

Perfect for:

UX/UI designers planning projects
Design system work
Feature design projects
Redesign initiatives
Stakeholder alignment

View design-brief-generator skill →

frontend-designer

Transform frontend design through progressive disclosure skills. Build accessible, responsive, high-performance user interfaces with modern CSS, design tokens, and component-driven architecture.

Key features:

Component generation with accessibility built-in
Design system setup with comprehensive tokens
WCAG 2.1 AA compliance auditing
Design tokens (colors, typography, spacing, shadows)
Responsive design patterns
Component library architecture
Accessibility-first approach
Performance optimization

Usage:

"Generate an accessible button component"
"Set up a design system with tokens"
"Audit this page for accessibility"
"Create a responsive card layout"
"Build a component library"

Includes:

generate_component.sh - Create accessible components (React, Vue, Vanilla JS)
setup_design_system.sh - Initialize design system with tokens
audit_accessibility.sh - Comprehensive WCAG 2.1 AA checker
Design tokens reference (colors, typography, spacing, etc.)
Accessibility checklist (complete WCAG 2.1 guide)
Responsive patterns (mobile-first, layouts, grids)
Component library architecture guide

Output:

design-system/
├── tokens/
│   ├── colors.css (brand, semantic, neutral)
│   ├── typography.css (fluid type, weights)
│   ├── spacing.css (spacing scale, containers)
│   ├── shadows.css (elevation system)
│   └── borders.css (radius, widths)
└── components/
    └── Button/
        ├── Button.tsx (accessible component)
        ├── Button.test.tsx (unit tests)
        ├── Button.module.css (scoped styles)
        └── Button.stories.tsx (Storybook)

Perfect for:

Frontend developers building design systems
Creating accessible user interfaces
Implementing responsive layouts
Component library development
WCAG 2.1 AA compliance
Modern CSS architecture
Design token systems

Features in depth:

Accessibility: Focus management, ARIA attributes, keyboard navigation, screen reader support
Responsive: Mobile-first, fluid typography, container queries, responsive images
Components: Button, Input, Card, Modal, Dropdown with variants and states
Design Tokens: CSS custom properties for theming, dark mode support
Testing: Unit tests, accessibility tests, visual regression
Performance: Code splitting, lazy loading, optimized rendering

Use with Claude:

"Using the frontend-designer skill, create an accessible navigation
component with mobile menu, keyboard support, and WCAG 2.1 compliance"

"Set up a design system with design tokens following the
frontend-designer patterns"

"Audit my landing page for accessibility issues using the
frontend-designer skill"

View frontend-designer skill →

apple-hig-designer

Design native iOS apps following Apple's Human Interface Guidelines. Create accessible, intuitive interfaces for iPhone, iPad, and Apple Watch with SwiftUI and UIKit components that feel truly native.

Key features:

iOS component generation (SwiftUI & UIKit)
Apple HIG compliance validation
iOS accessibility auditing (VoiceOver, Dynamic Type)
San Francisco font system & Dynamic Type
Semantic colors with automatic dark mode
8-point grid system & safe areas
Native iOS patterns & components
SF Symbols integration

Usage:

"Generate an iOS button component in SwiftUI"
"Validate my design against Apple HIG"
"Audit this view for iOS accessibility"
"Show me navigation patterns for iOS"
"Create a list view with proper spacing"

Includes:

generate_ios_component.sh - Create SwiftUI/UIKit components
validate_design.sh - Check Apple HIG compliance
audit_accessibility.sh - iOS accessibility checker
Typography reference (San Francisco, Dynamic Type)
Colors reference (semantic colors, dark mode)
Components catalog (buttons, lists, navigation, modals)
Accessibility guide (VoiceOver, reduce motion, contrast)
Layout & spacing guide (8pt grid, safe areas, touch targets)

Perfect for:

iOS app developers
SwiftUI & UIKit development
Native iOS design
Apple HIG compliance
iOS accessibility (VoiceOver, Dynamic Type)
iPad multitasking support
Apple Watch app design

Design Principles:

Clarity: Clean, focused content
Deference: UI supports content, doesn't compete
Depth: Visual layers and realistic motion

Components Covered:

Navigation: NavigationStack, TabView, Toolbar
Controls: Button, Toggle, Slider, Picker, TextField
Content: List, ScrollView, Grid
Presentations: Sheet, Alert, ConfirmationDialog
Indicators: ProgressView, Activity Indicator

Accessibility Features:

VoiceOver labels, hints, values
Dynamic Type (11 size categories)
Reduce Motion support
Increase Contrast support
Minimum 44pt touch targets
Color contrast validation

Use with Claude:

"Using apple-hig-designer, create a SwiftUI navigation view
with proper large titles and accessibility support"

"Validate my iOS app design against Apple HIG guidelines"

"Audit this SwiftUI view for VoiceOver and Dynamic Type compliance"

View apple-hig-designer skill →

book-illustrator

🎨 Expert children's book illustrator guide with 2024-2025 best practices. Focuses on age-appropriate styles, color theory, character design, and visual storytelling for kids books that captivate young readers.

Key features:

Age-appropriate design (ages 0-12)
Character development and expressiveness
Color theory for emotion and mood
Visual storytelling through composition
Current illustration trends and timeless techniques
Professional illustration standards
Print and digital publishing requirements

Usage:

"Design a character for a children's book about friendship"
"Create a color palette for a bedtime story"
"Develop illustration guidelines for ages 4-6"
"Plan visual storytelling for a picture book"

Includes:

Character design principles
Color theory and psychology
Composition and layout techniques
Illustration style guide
Age-specific design considerations

Perfect for:

Children's book illustrators
Graphic designers working on kids content
Authors self-publishing picture books
Art directors for children's publishing

View book-illustrator skill →

Content & Writing Skills

content-brief-generator

Generate comprehensive content briefs for writers, ensuring strategic, SEO-optimized content across all formats.

Key features:

Interactive content brief generation
SEO strategy and keyword research framework
Content structure frameworks (AIDA, PAS, How-To, etc.)
Tone and voice development guide
Brief validation and completeness checking
Templates for blog posts, documentation, landing pages, and more

Usage:

"Create a blog post brief for JWT authentication"
"Generate a landing page brief"
"Help me write a technical documentation brief"
"What SEO keywords should I target?"
"Validate my content brief"

Includes:

generate_brief.sh - Interactive brief generation
validate_brief.sh - Brief completeness validation
Complete SEO guidelines and best practices
Content structure frameworks (AIDA, PAS, storytelling, etc.)
Tone and voice development guide
Copywriting formulas and templates

Perfect for:

Content writers and marketers
Technical writers
Copywriters
Content strategists
SEO specialists

View content-brief-generator skill →

kids-book-writer

📚 Expert children's book writer creating delightful, engaging books for ages 2-9. Specializes in rhyming books, stories, songs with proper values, educational content, and age-appropriate language. Crafts books that captivate young readers while teaching important life lessons.

Key features:

Rhyming books with perfect meter and rhythm
Picture book stories with engaging narratives
Songs and poems for young learners
Educational content (phonics, sight words, vocabulary)
Values and life lessons (kindness, empathy, courage)
Age-appropriate language for reading stages
Interactive elements (call-and-response, repetition)
Illustration guidance for bringing stories to life

Usage:

"Write a rhyming book about sharing for 3-year-olds"
"Create a bedtime story with a lesson about courage"
"Generate a phonics song for letter sounds"
"Write a picture book about making friends"

Includes:

Age-appropriate writing guidelines
Story structure frameworks
Rhyming techniques and patterns
Values and themes reference
Bestseller elements guide

Perfect for:

Children's book authors
Parents creating custom stories
Educators developing reading materials
Content creators for kids

View kids-book-writer skill →

Trading & Finance Skills

trading-plan-generator

Generate comprehensive trading plans with risk management, position sizing, and discipline frameworks for consistent, profitable trading.

Key features:

Interactive trading plan generation
Risk management frameworks (1% rule, daily loss limits)
Position sizing calculators
Entry/exit strategy templates
Trading psychology and discipline guide
Performance tracking metrics
Plan validation and compliance checking

Usage:

"Create a trading plan for swing trading"
"Calculate position size for this trade"
"What should my daily loss limit be?"
"Help me set up risk management rules"
"Validate my trading plan"

Includes:

generate_plan.sh - Interactive plan generation (7 steps)
validate_plan.sh - Plan completeness validation
position_calculator.sh - Quick position sizing tool
Complete risk management guide (1% rule, R:R, stops)
Trading psychology reference (emotions, discipline, tilt)
Performance metrics and tracking frameworks

Perfect for:

Day traders
Swing traders
Position traders
Options traders
Anyone serious about trading discipline

⚠️ Important: This provides frameworks, not financial advice. Trading involves substantial risk of loss.

View trading-plan-generator skill →

Database & Query Skills

query-expert

Master SQL and database queries across multiple systems. Generate optimized queries, analyze performance with EXPLAIN plans, design effective indexes, and troubleshoot slow queries for PostgreSQL, MySQL, MongoDB, and more.

Key features:

Interactive query generation (SQL, MongoDB, GraphQL)
Query optimization analysis with recommendations
EXPLAIN plan interpretation guide
Index strategy recommendations
Performance troubleshooting
Multi-database support
Best practices and anti-patterns
Automated query scoring

Usage:

"Generate an optimized SELECT query with JOINs"
"Analyze this slow query and suggest optimizations"
"How do I interpret this EXPLAIN output?"
"Create indexes for better performance"
"Convert this SQL to MongoDB aggregation"

Includes:

generate_query.sh - Interactive query generator
optimize_query.sh - Query optimization analyzer
analyze_performance.sh - EXPLAIN plan guide & performance analysis
SQL patterns reference (SELECT, JOIN, GROUP BY, CTEs, window functions)
Indexing strategies (composite, covering, partial indexes)
Query optimization techniques
NoSQL queries (MongoDB, GraphQL)

Databases Supported:

SQL: PostgreSQL, MySQL, SQLite, SQL Server, Oracle
NoSQL: MongoDB, Redis, Elasticsearch, Cassandra
Query Languages: SQL, MongoDB Query Language, GraphQL, Cypher

Query Patterns:

SELECT with JOINs (INNER, LEFT, RIGHT, FULL OUTER)
Aggregation (GROUP BY, HAVING, aggregates)
Window functions (ROW_NUMBER, RANK, running totals)
CTEs (Common Table Expressions)
Subqueries and correlated subqueries
MongoDB aggregation pipelines
GraphQL queries with fragments

Optimization Techniques:

Avoid SELECT * (select only needed columns)
Index creation on WHERE/JOIN/ORDER BY columns
Composite index column ordering
Covering indexes for index-only scans
EXISTS vs IN for subqueries
Batch operations
LIMIT/pagination
Query plan analysis

Performance Analysis:

PostgreSQL EXPLAIN ANALYZE interpretation
MySQL EXPLAIN output analysis
MongoDB explain() stats
Index usage verification
Table scan detection
JOIN type optimization
Automated performance scoring

Use with Claude:

"Using query-expert, generate an optimized query to get
top 10 customers by total order value with their details"

"Analyze this query and suggest performance improvements:
SELECT * FROM orders WHERE YEAR(created_at) = 2024"

"Explain what this EXPLAIN ANALYZE output means and
how to optimize the query"

View query-expert skill →

QA & Testing Skills

qa-test-planner

Generate comprehensive test plans, manual test cases, regression suites, and bug reports for QA engineers. Includes Figma MCP integration for design validation.

Key features:

Interactive test case generation
Test plan templates and strategy
Regression test suite builder
Figma design validation (with MCP)
Bug report templates
Test coverage analysis
Test execution tracking

Usage:

"Create test cases for login feature"
"Generate a regression test suite"
"Validate UI against Figma design"
"Create a bug report for payment issue"
"Build a test plan for new feature"

Includes:

generate_test_cases.sh - Interactive test case creation
create_bug_report.sh - Structured bug documentation
Figma validation guide (design-implementation comparison)
Regression testing best practices
Test plan templates and examples
Bug severity and priority frameworks

Perfect for:

QA Engineers
Manual testers
Regression testers
UI/Visual testers
Test leads and managers

🎨 Figma MCP: When configured, enables design-implementation validation and visual testing.

View qa-test-planner skill →

Educational & Learning Skills

math-teacher

🎓 Interactive math teacher that instantly generates playful, gamified learning experiences. Creates visual playgrounds, interactive artifacts, and engaging games for kids and adults to learn math from basic arithmetic to advanced calculus.

Key features:

Instant playground generation - creates HTML artifacts on demand
Adaptive learning - scales from elementary to college level
Visual learning - graphs, animations, interactive visualizations
Gamification - points, achievements, challenges, progress tracking
Question-driven - user asks, teacher generates custom experiences
Playful techniques - engaging animations, rewards, fun challenges
No setup required - all artifacts work standalone in browser

Topics covered:

Elementary: Fractions, multiplication, geometry, patterns, time & money
Middle School: Linear equations, ratios, percentages, statistics, Pythagorean theorem
High School: Quadratics, trigonometry, exponentials, logarithms, polynomials
Advanced: Derivatives, integrals, limits, optimization, differential equations

Usage:

"Help me understand fractions"
"Show me how derivatives work"
"I don't understand quadratic functions"
"Challenge me on mental math"
"Let me explore the Pythagorean theorem"

Includes:

generate_playground.sh - Create interactive math playground
generate_game.sh - Build gamified math challenge
Complete reference materials (basic_math, algebra, calculus, gamification)
Interactive visualization templates
Game mechanics and reward systems

Perfect for:

Students learning math concepts
Teachers creating interactive lessons
Parents helping kids with homework
Adults refreshing math skills
Anyone wanting to make math fun

Example artifacts:

🍕 Fraction Pizza Party - visual fraction explorer with sliders
📊 Quadratic Explorer - real-time parabola graphing with coefficients
📈 Derivative Visualizer - tangent lines and limit animations
🎮 Speed Math Challenge - timed game with progressive difficulty
🧩 Pattern Finder - discover number sequences interactively

Use with Claude:

"Using math-teacher, help me understand how integrals work"

"Create an interactive playground for learning quadratic functions"

"Generate a fun math game for practicing multiplication"

View math-teacher skill →

reading-teacher

📚 Interactive reading teacher that instantly generates playful, engaging learning experiences for children ages 1-10. Creates visual playgrounds, phonics games, and interactive stories to build reading skills from letter recognition to comprehension.

Key features:

Instant playground generation - creates HTML artifacts on demand
Age-appropriate content - tailored for ages 1-10 with developmental stages
Multi-sensory learning - visual, auditory, and interactive elements
Phonics & sight words - systematic instruction and high-frequency words
Story building - interactive creation and comprehension activities
Gamification - stars, badges, rewards, and progress tracking
Parent/teacher tools - progress reports and customization options

Reading stages:

Pre-Reading (Ages 1-3): Letter recognition, sounds, phonemic awareness
Early Reading (Ages 3-5): Letter-sound correspondence, CVC words, simple sight words
Beginning Readers (Ages 5-7): Phonics patterns, expanding sight words, simple sentences
Developing Readers (Ages 7-10): Advanced phonics, comprehension, vocabulary

Usage:

"Help my toddler learn letters"
"Practice sight words for first grade"
"Phonics games for kindergarten"
"Reading comprehension for 2nd grade"
"Build a story with my child"

Includes:

generate_playground.sh - Create interactive reading playground
generate_game.sh - Build phonics or sight word game
Complete reference materials (phonics, sight_words, comprehension)
Interactive activity templates
Progress tracking systems

Perfect for:

Parents teaching young children
Homeschool reading instruction
Early literacy educators
ESL/ELL learners
Reading intervention support

Example artifacts:

🔤 Letter Land Adventure - interactive alphabet with sounds
📖 Sight Word Safari - timed recognition challenges
🎯 Phonics Matching - CVC word building games
📚 Story Builder Studio - create and read stories
🧩 Word Family Explorer - rhyming and pattern practice

Use with Claude:

"Using reading-teacher, help my 4-year-old learn letter sounds"

"Create a sight word practice game for kindergarten"

"Generate an interactive story for reading comprehension"

View reading-teacher skill →

leetcode-teacher

🚀 Interactive LeetCode-style teacher for mastering technical interviews. Generates browser-based coding playgrounds with real product challenges, teaches the 20 essential patterns, supports Python/TypeScript/Kotlin/Swift, and provides progressive difficulty training.

Key features:

Interactive code editor - browser-based with syntax highlighting
Multi-language support - Python, TypeScript, Kotlin, Swift
Real product challenges - Instagram, Uber, Netflix, Amazon scenarios
Pattern recognition - Master the 20 essential coding patterns
Progressive difficulty - Easy → Medium → Hard → Expert
Instant feedback - Run tests in real-time with detailed explanations
Technique teaching - Learn optimization strategies

Patterns covered:

Arrays: Two Pointers, Sliding Window, Fast & Slow Pointers
Trees & Graphs: BFS, DFS, Topological Sort
Dynamic Programming: Knapsack, Fibonacci, LCS
Advanced: Binary Search, Top K, Backtracking, Union Find, Tries

Usage:

"Practice two pointers with Instagram example"
"Generate sliding window problem for Netflix"
"Teach me BFS with LinkedIn connections"
"Hard dynamic programming challenge"
"Show me all heap patterns"

Includes:

generate_playground.sh - Create interactive coding environments
generate_problem.sh - Generate specific problem types
Complete reference materials (patterns, data_structures)
Multi-language code templates
Real product scenario examples

Perfect for:

FAANG interview preparation
Coding pattern mastery
Algorithm practice
Technical interview training
Competitive programming

Example challenges:

🎯 Two Sum (Instagram Mutual Likes)
📊 Top K Elements (Reddit Top Posts)
🔗 BFS (LinkedIn Degrees of Connection)
📅 Merge Intervals (Google Calendar Slots)
🚗 Shortest Path (Uber Driver Matching)

Use with Claude:

"Using leetcode-teacher, create a two pointers playground for Instagram"

"Generate a BFS problem with LinkedIn connections context"

"Show me sliding window pattern with Netflix recommendations"

View leetcode-teacher skill →

Installation

You have two ways to use this skills collection:

Option 1: Install ALL Skills (Bundle)

Get all 23 skills at once with intelligent routing:

/plugin marketplace add jamesrochabrun/skills
/plugin install all-skills@skills-marketplace

When to use this:

You want access to all skills
You prefer Claude to automatically choose relevant skills
You work across multiple domains (engineering, product, design, etc.)

Option 2: Install Individual Skills

Pick only the skills you need for better performance and focused context:

# First, add the marketplace
/plugin marketplace add jamesrochabrun/skills

# Then install specific skills
/plugin install anthropic-architect@skills-marketplace
/plugin install prd-generator@skills-marketplace
/plugin install frontend-designer@skills-marketplace
# ... install any skills you need

When to use this:

You work in specific domains
You want optimal performance with smaller context
You prefer explicit skill activation

Available Individual Skills

AI & Architecture:

/plugin install anthropic-architect@skills-marketplace
/plugin install anthropic-prompt-engineer@skills-marketplace

Engineering:

/plugin install openai-prompt-engineer@skills-marketplace
/plugin install git-worktrees@skills-marketplace
/plugin install llm-router@skills-marketplace
/plugin install engineer-expertise-extractor@skills-marketplace
/plugin install engineer-skill-creator@skills-marketplace

Product Management:

/plugin install prd-generator@skills-marketplace
/plugin install technical-launch-planner@skills-marketplace

Design:

/plugin install design-brief-generator@skills-marketplace
/plugin install frontend-designer@skills-marketplace
/plugin install apple-hig-designer@skills-marketplace
/plugin install book-illustrator@skills-marketplace

Content & Writing:

/plugin install content-brief-generator@skills-marketplace
/plugin install kids-book-writer@skills-marketplace

Trading & Finance:

/plugin install trading-plan-generator@skills-marketplace

Database & Query:

/plugin install query-expert@skills-marketplace

QA & Testing:

/plugin install qa-test-planner@skills-marketplace

Educational & Learning:

/plugin install math-teacher@skills-marketplace
/plugin install reading-teacher@skills-marketplace
/plugin install leetcode-teacher@skills-marketplace

Apple Development:

/plugin install swift-concurrency@skills-marketplace
/plugin install swiftui-animation@skills-marketplace
/plugin install releasing-macos-apps@skills-marketplace

Plugin Structure

The plugin follows the standard Claude Code plugin architecture:

skills/
├── .claude-plugin/
│   ├── plugin.json          # Plugin metadata
│   └── marketplace.json     # Marketplace configuration (25 plugins: 1 bundle + 24 individual)
├── skills/                   # All skills collection (24 total)
│   ├── anthropic-architect/
│   ├── anthropic-prompt-engineer/
│   ├── openai-prompt-engineer/
│   ├── git-worktrees/
│   ├── llm-router/
│   ├── engineer-expertise-extractor/
│   ├── engineer-skill-creator/
│   ├── swift-concurrency/
│   ├── swiftui-animation/
│   ├── releasing-macos-apps/
│   ├── prd-generator/
│   ├── technical-launch-planner/
│   ├── design-brief-generator/
│   ├── frontend-designer/
│   ├── apple-hig-designer/
│   ├── book-illustrator/
│   ├── content-brief-generator/
│   ├── kids-book-writer/
│   ├── trading-plan-generator/
│   ├── query-expert/
│   ├── qa-test-planner/
│   ├── math-teacher/
│   ├── reading-teacher/
│   └── leetcode-teacher/
├── README.md                 # This file
└── LICENSE

How It Works

Marketplace Configuration:

The marketplace.json exposes 25 installable options
1 "all-skills" bundle with strict: false (intelligent routing across all 24 skills)
24 individual skills with strict: true (explicit activation when installed)

Installation Flexibility:

Install the bundle for comprehensive coverage with smart skill selection
Install individual skills for focused, high-performance context
Mix and match based on your needs

Requirements

Claude Code
Skills may have their own dependencies (check individual skill README)

Contributing

Feel free to contribute additional skills or improvements via pull requests.

License

MIT License - See individual skills for their specific licenses.

Architecture

This marketplace provides flexible installation options:

Bundle Installation (all-skills)

What: All 23 skills in one package
Behavior: strict: false enables intelligent skill routing
Best for: Users who work across multiple domains and want comprehensive coverage
Trade-off: Larger context window, but Claude automatically selects relevant skills

Individual Installation

What: Install only specific skills you need
Behavior: strict: true ensures explicit skill activation
Best for: Focused workflows in specific domains (e.g., only engineering or only design)
Trade-off: Smaller context window for better performance, but requires manual skill selection

Technical Details

marketplace.json structure:

24 total plugin entries
1 "all-skills" bundle pointing to root with all 23 skills
23 individual plugins, each pointing to a single skill
All use same repository source (./) with different skill paths

Why this works:

No duplication: Skills live in one place (skills/ directory)
Flexible installation: Users choose bundle vs individual
No maintenance burden: No individual plugin.json files needed
Clean architecture: Single source of truth in marketplace.json

For more information about Claude Code plugins and marketplaces, visit the official documentation.

Credits

Created by @jamesrochabrun

Built for use with Claude Code by Anthropic.

Version

Current Version: 2.2.0

What's New in 2.2.0:

📦 releasing-macos-apps - Complete macOS release workflow with notarization
🍎 Renamed category to "Apple Development" (3 skills)
🔑 API Key authentication for notarization (App Store Connect)
🔐 Multiple Sparkle key storage options
🎯 25 installable options (1 bundle + 24 individual skills)

What's New in 2.1.0:

🍎 New iOS & Swift Development category with 2 skills
⚡ swift-concurrency - Modern Swift 6+ concurrency patterns
🎬 swiftui-animation - Advanced animations and Metal shaders
🎯 24 installable options (1 bundle + 23 individual skills)

What's New in 2.0.0:

✨ Individual skill installation support
⚡ Better performance with focused skill selection
🔧 Smart routing with strict: false for bundle, strict: true for individual skills

See marketplace.json for complete configuration.