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:

1. Extract: engineer-expertise-extractor → Creates profile
2. Create: engineer-skill-creator → Transforms into skill
3. 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.