Skills are superpower packs for AI coding agents. From workflows to code review, design to security — curated daily for 10x productivity.
Premium brand-kit: logos, identity decks, visual worlds
Elite UX/UI + GSAP motion, AIDA structure, bento grids
Component architecture, design systems, responsive, WCAG 2.1 AA
Design like a high-end agency: fonts, spacing, shadows
Raw mechanical interfaces, Swiss typography + military terminal
Generate design images first, then implement to match
Create distinctive, intentional frontend visual design that avoids templated AI aesthetics.
Systematic UI/UX design review — heuristic evaluation, accessibility audit, visual consistency check, responsive design review, interaction design feedback.
Generates accessible color palettes and contrast ratios from a seed color.
Design system toolkit for generating design tokens, component architecture, responsive design, and developer handoff.
23K+ star text content humanization skill — makes AI-generated text read naturally human. Detects and removes AI-typical patterns in writing.
Optimizes CSS Grid and Flexbox layouts for responsive breakpoints using AI.
Create Awwwards-level premium landing pages with bold visual storytelling, immersive scroll experiences, and GSAP ScrollTrigger orchestration.
Parses code comments and OpenAPI specs to generate up-to-date API documentation.
Architecture documentation generator that visualizes component diagrams and data flows.
Builds and validates OpenAPI/Swagger specs from code annotations.
Generates and refines CSS animations, transitions, and micro-interactions with performance insights.
Analyzes CSS architecture, suggests refactors, and generates maintainable BEM/utility-first styles.
Scans UI components for WCAG 2.2 accessibility violations and suggests fixes
Suggests CSS keyframe or GSAP animations based on UI element interaction intent.
Automatically audits and fixes accessibility issues in HTML/CSS, including ARIA roles and color contrast.
Inject creative aesthetic sensibility — break through AI template aesthetics with brand personality, art direction, and cultural references.
Converts Figma design components directly into React components with Tailwind CSS
Scans a React component or HTML page for accessibility violations and suggests fixes with ARIA attribute injection.
Automatically audits and fixes WCAG 2.2/3.0 violations in HTML, React, Vue, and Angular
Scans and automatically fixes accessibility violations in JSX and HTML using WCAG 2.2 rules.
Matches custom components to existing design token libraries automatically.
Scans UI for WCAG violations and auto-fixes with ARIA attributes or color adjustments
Syncs design tokens from Figma to codebase as CSS variables or Tailwind config automatically.
Automatically scans and reports WCAG 2.2 compliance issues in live web pages or design mockups.
Converts Figma design tokens directly into Tailwind CSS utility classes and component code
Converts natural language layout descriptions into complex CSS Grid and Subgrid code.
Build and maintain component libraries with Storybook — component API design, variant documentation, visual regression testing, accessibility testing, versioning strategy.
Creates interactive CSS/GSAP animation previews from natural language motion descriptions.
Lints CSS/SCSS files with Stylelint and auto-applies fixes for common style errors and naming conventions.
Adjusts CSS and design tokens interactively with AI-suggested improvements
Designs and implements micro-interactions (hover, click, scroll) with pure CSS or GSAP.
Extract design tokens and components from Figma into Claude Code context
Generates custom CSS Houdini paint worklets and animation worklets from visual examples.
Simulates how a UI appears to users with various disabilities (color blindness, low vision, motor impairments).
Generates CSS keyframe or Lottie animation previews from natural language descriptions, with timeline editing
Scans live frontend and produces a prioritized WCAG 2.2 accessibility report with fixed code snippets.
Analyzes and optimizes Dockerfiles for smaller image size and faster builds.
Integrates Supabase database management directly into Claude Code for schema design and query execution.
Creates complex CSS and JavaScript animations from simple motion descriptions.
Generate performant, accessible CSS animations and transitions with compositor-only performance best practices.
Builds and queries a dependency graph of your codebase to find hidden relationships
Converts arbitrary CSS declarations into equivalent Tailwind utility classes
Bridges Figma design tokens and components into Claude Code for real-time design-to-code synchronization.
Generates architectural diagrams from source code structure and dependency trees.
Discovers and enforces design system patterns across a codebase, detecting inconsistencies
Automatically adjusts color palettes in CSS/design tokens to meet WCAG AA/AAA contrast ratios.
Advanced Tailwind CSS patterns — custom theme configuration, plugin development, responsive strategies, dark mode, performance optimization, Tailwind v4 migration.
Syncs design tokens from Studio tokens to CSS custom properties and Tailwind config.
Creates CSS animations and keyframes from high-level motion descriptions
Compares screenshots across builds to detect visual regressions
Auto-adapts layouts across breakpoints, generating responsive CSS and media queries
Generates architecture diagrams (C4, UML) by scanning code dependencies and project structure.
Next.js App Router patterns — RSC, Server Actions, streaming, ISR, middleware, route groups, parallel routes, intercepting routes, authentication patterns.
Generates WCAG-compliant UI components with semantic HTML and ARIA attributes from wireframe sketches.
Converts Figma designs into production-ready React components with Tailwind CSS.
Animation design principles — easing curves, timing, staging, choreography. Framer Motion + GSAP patterns. Page transitions, scroll-driven animations, micro-interactions.
UI/UX design skill for generating and refining design specs with Claude Code
Generates accessible color palettes and dark/light theme tokens from brand input, with contrast checks
Guide Claude Code through structured multi-step reasoning for complex tasks
Automatically generates Google-style docstrings for Python functions and classes.
Generates and refactors Tailwind CSS utility classes directly from Claude Code prompts.
Analyzes design mockups and generates reusable Vue/React component trees
Generates polished CSS/GSAP micro-interactions from natural language descriptions or gesture prototypes.
Generates accessible React components using ARIA patterns and WCAG 2.2 AA compliance by default.
Analyzes brand colors and generates a complete Tailwind CSS color palette with contrast ratios.
Generates React/Vue/Svelte components from design specs.
Generates React components from hand-drawn wireframes or screenshots in real time.
Inspects and visualizes code dependency graphs and architecture
UI component design skill for Claude Code to generate and preview interfaces
Applies design patterns and generates architecture diagrams automatically
Enforces design system consistency across codebases by detecting style drift and auto-fixing mismatches.
Generates Storybook docs, auto-changelog, and usage examples for any React/Vue component library.
Performs automated accessibility audits on UI code and suggests fixes with ARIA and semantic HTML.
Generates architecture diagrams and flowcharts from code for Claude Code
Generates TypeScript types and validation schemas from OpenAPI specs automatically.
Convert Figma designs directly into React components via Claude Code
Automatically adjusts CSS breakpoints and layouts based on screen size data and user behavior.
Creates advanced scroll-driven animations and view transitions using the latest CSS and JS APIs.
Generates and updates architecture diagrams from code structure changes
Extracts design tokens (colors, typography, spacing) from any UI screenshot or Figma frame.
Converts Figma design tokens and components directly into production-ready code.
Converts Figma designs directly into React components with pixel-perfect accuracy.
Converts Sketch/Figma layers into Tailwind CSS or styled-components with pixel-perfect output
Refactors and minifies CSS bundles, removes unused styles, and merges duplicate rules with class generation
Creates SVG icons with built-in ARIA labels, focus indicators, and reduced-motion fallbacks from text prompts
Creates complex animation sequences with Framer Motion from natural language prompts.
Automatically extracts design tokens from Figma or Sketch and syncs them to CSS custom properties or Tailwind config.
Generates accessible color palettes for UI projects.
Converts static CSS animation snippets into interactive live previews with timeline controls.
Generates accessible color palettes from a brand color, ensuring contrast ratios and harmony
AI code formatter that enforces style guides and best practices across multiple languages.
Generates CSS/GSAP micro-interactions from drag-and-drop timeline inputs
Generates React/Vue components with TypeScript and Storybook stories from design tokens.
Interactive database schema design and migration assistant
Converts Lottie or JSON animations into optimized CSS keyframes for web use.
Extracts and generates design tokens from design files for multi-platform consistent theming.
Extracts design tokens from Figma files and generates CSS/SCSS/Tailwind variables.
Converts Figma design tokens into CSS variables, Tailwind configs, and Android/iOS theme files.
Extracts reusable UI components from existing codebases and generates design system documentation.
Generates state machines (XState or finite state) for UI components from interaction flow descriptions.
Transforms a light-mode CSS theme into a dark-mode palette using perceptual color mapping, with optional automatic toggle logic.
Generates architecture and flow diagrams from code analysis
Designs and exports micro-interactions (hover, click, scroll) as CSS keyframes or Lottie files.
Syncs design tokens from Figma to CSS custom properties and Tailwind config automatically.
Generates exhaustive component variants (states, sizes, themes) from a base component and design spec.
Generates interactive UI motion prototypes and micro-interaction specs from natural language descriptions.
Syncs design tokens from Figma to codebase automatically.
Creates accessible color palettes and gradient schemes from a seed color or brand guideline.
Creates CSS keyframe animations or GSAP timelines from natural language descriptions of motion effects.
Converts inline styles to optimized CSS classes and extracts critical CSS for performance.
Generates reactive UI components from natural language descriptions, auto-binding state and events.
Builds and optimizes scroll-driven animations using CSS scroll-timeline and View Transitions API.
Conducts deep research on software architectures and generates design docs
Builds a complete design system style guide page from a JSON token file, including color swatches, typography scale, and spacing examples.
Converts Figma variables into platform-specific design tokens (CSS, SwiftUI, Compose).
Automatically reformats code to match project style guides and lint rules.
Validates React component library against a JSON design spec, flagging style drift and auto-updating source code
Converts UI mockups into pixel-perfect React components
Converts Figma or sketch prototypes into clean React components with TypeScript and CSS modules.
Generates complete UI mockups from natural language descriptions using advanced diffusion models.
Automatically adjusts layouts for breakpoints and device types.
Creates reusable design system components with automatic dark mode and theme variants.
Converts wireframe sketches or low-fidelity mockups into React or Vue components with responsive styling.
Generates CSS keyframe animations or GSAP timelines from a natural language description of motion intent.
Generates keyframe animations or GSAP timelines from natural language descriptions of motion intent.
Creates interactive decision trees for complex logic exploration
Generates Kubernetes manifests and Helm charts based on deployment requirements.
Identifies layout, accessibility, and responsiveness issues by analyzing rendered component trees and CSS.
Compares screenshots of UI components before and after changes to detect unintended visual regressions.
Converts Figma design tokens and components directly into React code
Converts Figma design tokens into platform-specific CSS, Tailwind, or Style Dictionary formats.
Generates responsive grid and flexbox layouts with breakpoint suggestions from a sketch
Creates all visual variants of a UI component (hover, active, disabled, dark mode) from a base style
Generates and runs visual regression tests for UI component libraries
Bridges design system tokens to multiple front-end frameworks automatically.
Builds and visualizes reasoning graphs for complex problem-solving and decision trees.
Automatically stitches micro-frontend modules with shared state
Automatically audits and fixes WCAG accessibility violations in HTML/CSS codebases.
Analyzes and optimizes CSS animations for 60fps performance, suggesting will-change and transform-based alternatives.
Takes a base component and auto-generates responsive variants for mobile, tablet, and desktop using breakpoint-tailored CSS.
Automated visual diff testing for UI components using AI-driven pixel comparison.
Analyzes a Figma or Sketch file to extract and export design tokens (colors, spacing, typography) as CSS variables or JSON.
Builds native iOS/macOS Swift bridges for Claude Code to execute Swift scripts directly.
Suggests subtle micro-interactions and CSS transitions to improve UX based on user flow analysis.
Reads design tokens from Figma or Theme files and syncs them into CSS variables and Tailwind config.
Generates multiple UI variants (hover, focus, error, dark mode) from a single base component definition.
Creates interactive UI mockups from natural language descriptions and integrates with design tools.
Generates React/Vue components from wireframe images using vision-language models
Analyzes UI components and suggests optimal responsive breakpoints, grid structures, and container queries.
Uses AI to adjust color palettes for maximum readability and WCAG AAA compliance without losing brand identity.
Generates React/Vue UI components from natural language descriptions
Designs GraphQL schemas interactively and generates resolvers and type definitions.
Creates complex CSS animations and micro-interactions from plain English descriptions.
Analyzes UI component usage and suggests performance optimizations.
Detects visual regressions in PRs and auto-generates CSS fixes to restore pixel-perfect designs.
Optimizes micro-frontend architecture by automating module federation and shared dependency bundling.
Generates complete React component UIs from hand-drawn wireframes or screenshots using vision models.
Analyzes existing CSS and component libraries to suggest and enforce a unified design system.
Validates UI designs against accessibility and consistency rules
Audits UI components for accessibility compliance and suggests fixes per WCAG guidelines.
Generates complete React/Tailwind UI components from natural language descriptions
Optimizes Tailwind CSS class usage by removing duplicates and suggesting utility combinations.
Automatically generates responsive CSS Grid/Flexbox layouts with breakpoints from component hierarchy.
Generates Lottie and CSS keyframe animations from natural language prompts for React and Vue apps.
Optimizes color palettes for accessibility contrast and brand harmony across themes
Creates and maintains a full design system with component variants, themes, and documentation
Generates and runs visual regression tests for Storybook stories, flagging CSS regressions
Automatically generates responsive grid and flexbox layouts from mockups.
Analyzes a light color scheme and generates a complete dark mode palette with WCAG-compliant contrasts.
Converts static SVG paths into animated draw-on effects with automatic timing and easing curve recommendations.
Automatically suggests optimal CSS breakpoints and media queries based on component content and user analytics.
Scans UI components for compliance with design tokens and component libraries, auto-fixing inconsistencies.
Generates and validates Terraform and CloudFormation templates from natural language.
Assembles UI components from natural language descriptions using design tokens.
Generates responsive CSS Grid and Flexbox layouts with breakpoints optimized for multiple devices.
Generates realistic mock APIs from OpenAPI specs for frontend and integration testing.
Generates a complete Svelte 5 design system with slots, transitions, and theme support.
Generates UI test automation scripts from visual mockups using computer vision.
Generates React/Vue components with built-in loading, empty, error, and edge case states from a single state machine definition.
Creates complex CSS keyframe animations from natural language prompts with easing presets.
Reads Figma design tokens and automatically syncs them into Tailwind CSS config and CSS custom properties.
Generates and maintains docstrings across entire codebases with style consistency
Generates architecture diagrams from code structure using AI analysis of imports and dependencies.
Tests UI across multiple screen sizes and input methods using visual and behavioral analysis.
Analyzes CSS bundles and suggests refactoring for performance (removes unused styles, reduces specificity, inlines critical CSS).
Generates complex CSS Grid layouts from simple row/column descriptions and visual examples.
Creates micro-interactions for buttons, toggles, and hover states with physics-based motion.
Creates complete, accessible UI components with props, styles, and tests from text prompts.
Automatically create and maintain scalable design token systems across multiple platforms.
Generates fully responsive CSS Grid and Flexbox layouts from wireframe sketches or text descriptions.
Designs fluid responsive layouts using modern CSS grid and container queries.
Extracts and generates design tokens from Figma or code for consistent design systems.
Assists in building complex Framer Motion animations for React with auto-generated presets.