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