Patterns for designing component hierarchies, composition, and reusable UI elements

Suggest and generate custom element compositions for a UI goal. Use when the user asks to "compose elements", "build a layout", "combine components", "create a page with", "what elements should I use for", or describes a UI they want to build using custom elements.

Guidelines for building production-ready Convex apps covering function organization, query patterns, validation, TypeScript usage, error handling, and the Zen of Convex design philosophy

This skill should be used when the user asks to "create an image", "generate an image", "make an illustration", "design a graphic", "generate a diagram", "make me a picture", "create a visual", "generate artwork", or mentions "banana squad", "nano banana", "image generation team". Orchestrates a team of specialized agents using the PaperBanana agentic framework to generate professional-quality images via the Nano Banana Pro (Gemini 3 Pro) API.

This skill should be used when the user asks to "create an MCP App", "add a UI to an MCP tool", "build an interactive MCP View", "scaffold an MCP App", or needs guidance on MCP Apps SDK patterns, UI-resource registration, MCP App lifecycle, or host integration. Provides comprehensive guidance for building MCP Apps with interactive UIs.

Database schema design, optimization, and migration patterns for PostgreSQL, MySQL, and NoSQL databases. Use for designing schemas, writing migrations, or optimizing queries.

Query and filter Datadog logs from the shell using the Composio CLI. Run scoped log searches, pivot across services/environments, and export structured JSON for downstream agents instead of click-driving the Datadog UI.

Record and look up decisions in notes/DECISIONS.md with dcn-xxxx reference codes. Use for logging architectural choices, design decisions, and team agreements, or finding past decisions. Triggers on: "log a decision", "we decided", "record this decision", "decision log", "what did we decide about", "find decision".

Give a structured product design critique — user job clarity, hierarchy, affordance, error states, accessibility, and consistency — focused on what to change, in what order, and why.

Use before any creative work - creating features, building components, adding functionality. Explores user intent, requirements, and design before implementation. One question at a time, multiple choice preferred.

Design system management for building and reusing UI components, tokens, and patterns. Use when working with component libraries, design tokens, style guides, or reusable UI patterns to ensure consistency and promote component reuse.

Audit UI code for design system compliance and AI slop markers. Triggers on: "review design system", "check design compliance", "audit UI code", "design system review", "check for AI slop", "design review", or /design-systems:review. Scans CSS, SCSS, JSX, TSX, Vue, and Svelte files against DESIGN.md rules and the AI Slop Instant Giveaways checklist.

Validate design documents for completeness, clarity, and feasibility

Generates distinctive, production-grade frontend code with bold aesthetic direction and meticulous visual detail. Activates when the user requests web components, pages, or applications that need polished UI design beyond generic templates.

Generate SPECs end-to-end from BDD/ADR, a prompt, or an IPLAN - detect input, generate the component spec, validate, and run the audit/fix cycle. Use to create or batch-create SPECs.

Evaluate UX/UI using Don Norman's 7 fundamental design principles from The Design of Everyday Things. Audit discoverability, affordances, signifiers, feedback, mapping, constraints and conceptual models.

Mechanically tighten existing prose — restructure sections by dependency order, split or merge paragraphs, remove redundancy. Use to compress verbose plan files, READMEs, ADRs, and design docs. Does NOT change voice, register, tone, or any ODIN-mandated phrasing.

Rewrite human-facing prose using Strunk-style rules. Use for docs, README files, technical explanations, PR descriptions, commit messages, error messages, UI copy, reports, and summaries when the user asks to polish, shorten, clarify, de-duplicate, restructure, or normalize tone.

Design environment strategy (dev / staging / prod, + possibly QA / demo / UAT / DR). Per-env purpose, data, access, isolation, prod-parity, refresh cadence, teardown. Ephemeral per-PR envs.

Design eval datasets that actually measure model quality — coverage, difficulty distribution, labeling consistency, and avoiding contamination. Covers sourcing, stratification, label quality, and when to generate vs curate. Use this skill when building a new eval set, realizing your current evals don't catch regressions, or labeling is inconsistent. Activate when: eval dataset, benchmark, test set, eval coverage, label quality, synthetic eval, dataset design.

Design event sourcing and/or CQRS. Event store, event schema, aggregate boundaries, projections, consistency, snapshotting, versioning / upcasting, replay, GDPR implications.

Extracts a sequence of workflow events from conversation context into a structured markdown list. Surfaces actors, state changes, and pain points to serve as raw data for any later synthesis, design planning, or spec development. Use when asked to document an actual operational flow, user journey, or scenario from a conversation to capture exactly what happened.

Classifies execution failures into F1-F5 (transient/local-logic/local-design/story-level/architectural). Outputs JSON with class, confidence, evidence, and recommended action. Deterministic rule-based classifier; no LLM call.

Implement state management using the BLoC/Cubit pattern with injectable dependency injection. Use when creating new BLoCs, managing UI state transitions, or configuring navigation with GoRouter.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

Side-by-side comparison of ruflo vs HAL vs other GAIA harnesses — capability gaps, design decisions, and improvement roadmap

Generate images using AI (OpenAI GPT Image or Stability AI). Use when the user asks to generate an image, create an AI image, make an illustration, or produce artwork from a text prompt.

Use when writing, reviewing, or debugging concurrent Go code. Covers goroutine lifecycle management, channels, errgroup, mutexes, atomics, sync.Map, and synchronous-first design. Based on Google and Uber style guides.

Use when starting a new Go project, organizing packages, or restructuring an existing Go codebase. Covers standard directory layout, package design, Makefile targets, Dockerfile patterns, and module setup.

Generates operations-focused guidance for Google Cloud workloads based on the design principles and recommendations in the Operational Excellence pillar of the Google Cloud Well-Architected Framework (WAF). Use this skill to evaluate a workload, identify operational requirements, and provide actionable recommendations for deployment, monitoring, and incident management.

Generates performance-focused guidance for Google Cloud workloads based on the design principles and recommendations in the Performance Optimization pillar of the Google Cloud Well-Architected Framework (WAF). Use this skill to evaluate a workload, identify performance requirements, and provide actionable recommendations for resource allocation, modular design, and elasticity.

Elite UX/UI & Advanced GSAP Motion Engineer. Enforces Python-driven true randomization for layout variance, strict AIDA page structure, wide editorial typography (bans 6-line wraps), gapless bento grids, strict GSAP ScrollTriggers (pinning, stacking, scrubbing), inline micro-images, and massive section spacing.

Elite UX/UI & Advanced GSAP Motion Engineer. Enforces Python-driven true randomization for layout variance, strict AIDA page structure, wide editorial typography (bans 6-line wraps), gapless bento grids, strict GSAP ScrollTriggers (pinning, stacking, scrubbing), inline micro-images, and massive section spacing.

Elite UX/UI & Advanced GSAP Motion Engineer. Enforces Python-driven true randomization for layout variance, strict AIDA page structure, wide editorial typography (bans 6-line wraps), gapless bento grids, strict GSAP ScrollTriggers (pinning, stacking, scrubbing), inline micro-images, and massive section spacing.

Professional graphic design principles for digital and print media. Use when creating visual designs, choosing color palettes, typography, layouts, or providing design feedback.

Design and review GraphQL schemas, resolvers, mutations, pagination, and data-loading patterns. Use when building or refactoring GraphQL APIs, adding fields, fixing resolver design, or improving GraphQL performance and safety.

When the user wants to design, optimize, or audit grid layouts for content display. Also use when the user mentions "grid layout," "grid design," "multi-column grid," "CSS grid," "responsive grid," "card grid," "product grid," or "feature grid." For cards layout, use card.

Use when the user wants a plan or design stress-tested before building it. Triggers on "grill me", "grill this plan", "stress-test this plan", "poke holes in this design", "interrogate this design/plan", AND on pre-implementation moments where a concrete plan or design is on the table and about to be implemented. Dispatches a separate read-only grill agent that interrogates the plan one question at a time; the main agent answers each question from the codebase and escalates only costly-to-reverse decisions (schema/contract, public API, data migration, security boundary) to the human.

Analyze code for internationalization issues, understanding the UI context and user impact before flagging problems. Use when reviewing code for global readiness.

Infrastructure as Code planning. Tool selection, module design, state management, environment separation, CI/CD integration, drift detection, policy-as-code, secrets handling.

Generate 8 distinct ASCII UI concepts per passed solution. Each concept visualizes the primary screen/interface using box-drawing characters. Style matches the solution's interaction model. Use when the user says "generate UIs", "create UI concepts", "ASCII mockups", or invokes /ideation:ui.

Use when you have a design or requirements for a multi-step task, before writing code. Creates bite-sized TDD task plans with exact file paths, complete code, and verification steps.

Raw mechanical interfaces fusing Swiss typographic print with military terminal aesthetics. Rigid grids, extreme type scale contrast, utilitarian color, analog degradation effects. For data-heavy dashboards, portfolios, or editorial sites that need to feel like declassified blueprints.

Raw mechanical interfaces fusing Swiss typographic print with military terminal aesthetics. Rigid grids, extreme type scale contrast, utilitarian color, analog degradation effects. For data-heavy dashboards, portfolios, or editorial sites that need to feel like declassified blueprints.

OWASP A08 - Insecure Deserialization Prevention. Use this skill when parsing serialized data, handling JSON with type information, or processing pickled/marshalled objects. Activate when: deserialization, JSON parse, pickle, marshal, serialize, unserialize, ObjectInputStream, yaml.load, eval JSON, prototype pollution.

Triage Linear or Jira backlogs and run bug sweeps via the Composio CLI. Bulk-fetch issues, dedupe, relabel, reassign, and post summaries — all from the shell without clicking through the UI.

Generates a product spec doc in Markdown from a Jira ticket. Use when the user provides a Jira ticket ID (e.g. CCC-284) or URL and asks for a spec, design doc, or tech spec ("write a spec for this ticket", "make a spec from this Jira").

When the user wants to design, optimize, or audit list layouts for content display. Also use when the user mentions "list layout," "list design," "vertical list," "stacked list," "blog list," "article list," "documentation list," "search results layout," or "infinite scroll list." For blog index page, use blog-page-generator.

Design prompts, schemas, validation, and recovery logic for reliable machine-readable model outputs. Use when generating JSON, typed objects, extraction results, tool arguments, or any output another system must parse safely.

Query public GitHub repos via DeepWiki MCP — AI-powered answers about architecture, internals, and design decisions without cloning. Use for: 'how does this repo work', 'explain the architecture of X', 'compare two frameworks'. No auth required.

Design MCP tool schemas, names, and descriptions that AI agents actually pick correctly and use without hand-holding. Covers the anti-patterns that make agents loop, pick wrong tools, or hallucinate arguments. Use this skill when designing or reviewing MCP tools, debugging "the agent isn't using my tool", or pruning a bloated tool surface. Activate when: MCP tool design, tool description, agent picks wrong tool, too many tools, tool schema, tool naming.

Teaches the mediator pattern for centralized component communication. Use when multiple components need to communicate and direct coupling between them creates complexity or tight dependencies.

Material-UI styling approaches

Create optimized multi-stage Dockerfiles for any language or framework. TRIGGER WHEN: creating Dockerfiles, optimizing container images, multi-stage builds, Docker best practices. DO NOT TRIGGER WHEN: the task is outside the specific scope of this component.

Generates AI images using the nano-banana CLI (Gemini 3.1 Flash default, Pro available). Handles multi-resolution (512-4K), aspect ratios, reference images for style transfer, green screen workflow for transparent assets, cost tracking, and exact dimension control. Use when asked to "generate an image", "create a sprite", "make an asset", "generate artwork", or any image generation task for UI mockups, game assets, videos, or marketing materials.

Next.js 16+ complete stack with App Router, Prisma 7, Better Auth, shadcn/ui, TanStack Form, Zustand. Use as the master reference combining all framework skills.

Nutrient React Native SDK — the @nutrient-sdk/react-native npm package (the legacy `pspdfkit-react-native` package is the pre-rebrand name). PSPDFKit rebranded to Nutrient; the npm package is now @nutrient-sdk/react-native and the main component is NutrientView (not PSPDFKitView). Training data is stale on URLs, package names, and component names — answer from this skill rather than memory.

Generate a live Single Step Instrumentation (SSI) onboarding confirmation report — verifies APM instrumentation is working end-to-end with deep links into the Datadog UI. Only use after agent-install and enable-ssi have both completed successfully.

Capture and automate macOS UI with the Peekaboo CLI.

Design and execute performance tests using k6, Artillery, and other tools. Use this skill when load testing APIs, stress testing systems, or establishing performance baselines. Activate when: performance test, load test, stress test, k6, artillery, benchmark, scalability testing.

Refine plans through multi-agent expert discussion. Use when user says "get multiple expert opinions on this plan", "I want different perspectives on this approach", "have the agents discuss this strategy", "refine the plan through collaborative review", or "what would different specialists think about this design".

When the user wants to plan, design, or optimize pricing strategy and structure. Also use when the user mentions "pricing strategy," "pricing model," "pricing tiers," "freemium," "value-based pricing," "anchoring," "price structure," or "monetization strategy." For pricing page, use pricing-page-generator.

Prototype pollution testing for JavaScript stacks. Use when user input is merged into objects (query parsers, JSON bodies, deep assign), when configuring libraries via untrusted keys, or when hunting RCE gadgets via polluted Object.prototype in Node or the browser.

React renderer for json-render that turns JSON specs into React components. Use when working with @json-render/react, building React UIs from JSON, creating component catalogs, or rendering AI-generated specs.

Use this skill when refactoring code with AI assistance. Activate when the user wants to improve code structure, extract functions, reduce complexity, modernize legacy code, apply design patterns, clean up technical debt, or restructure code while preserving behavior.

Multi-agent research orchestration for gathering technical, architectural, UX, security, and competitive insights. Use before brainstorm, during planning, or for troubleshooting.

Validate technical designs against requirements for coverage, feasibility, and architectural soundness. Use after creating a design.

Generates Request for Comments documents for technical proposals including problem statement, solution design, alternatives, risks, and rollout plans. Use for "RFC", "technical proposals", "design docs", or "architecture proposals".

Design database schemas with proper normalization, relationships, constraints, and indexes. Use when creating database tables, modeling data relationships, or designing database structure.

Refine requirements on a Linear ticket through Socratic dialogue. Use this when the user wants to think through a problem, clarify requirements, or evaluate options before starting design work.

Design secrets management — vault selection, lifecycle (generation / distribution / rotation / revocation), access control, injection pattern, audit, CI/CD integration, break-glass.

Generate N independent reasoning paths and vote on the answer. Use for architectural trade-offs, ambiguous design decisions, or when single-path reasoning risks locking onto the first plausible answer. Paper: Wang et al. 2022.

Set up a Cairo smart contract project with OpenZeppelin Contracts for Cairo on Starknet. Use when users need to: (1) create a new Scarb/Starknet project, (2) add OpenZeppelin Contracts for Cairo dependencies to Scarb.toml, (3) configure individual or umbrella OpenZeppelin packages, or (4) understand Cairo import conventions and component patterns for OpenZeppelin.

Shadcn/ui-inspired design with minimal, clean components, monochrome palette, and utility-first patterns.

Use Shopify Polaris Web Components (s-* custom elements) for App Home UI. Use when building App Home surfaces (not embedded apps), designing UI with s-page, s-section, s-stack, s-box, s-button, and other s-* components. Do not use @shopify/polaris React - App Home requires Web Components.

When the user wants to design, optimize, or audit a sidebar for blogs, docs, or content pages. Also use when the user mentions "sidebar," "blog sidebar," "content sidebar," "side panel," "sidebar navigation," "related content," "sidebar CTA," "doc sidebar," or "sidebar widgets." For blog layout, use blog-page-generator.

Guide users through creating Agent Skills for Claude Code. Use when the user wants to create, write, author, or design a new Skill, or needs help with SKILL.md files, frontmatter, or skill structure.

Run the SPARC Architecture and Implementation phases — design module boundaries, write pseudocode, implement code, and run tests

Design and operationalize SRE dashboards that surface reliability, latency, error, saturation, and capacity signals across services. Use when building observability views for SLOs, incident response, and executive reliability reporting.

Design systems with appropriate complexity—no more, no less. Use this skill when the user asks to architect applications, design system boundaries, or make structural decisions. Generates pragmatic architectures that solve real problems without premature abstraction.

Guide architectural design decisions for software systems. Use this skill when designing new systems, evaluating architecture trade-offs, or creating technical design documents. Helps produce clear, well-structured design artifacts including component diagrams, data flow, and decision records.

Tailwind responsive design patterns

Headless UI for virtualizing large element lists at 60FPS in TS/JS, React, Vue, Solid, Svelte, Lit & Angular.

Use when choosing a testing approach for a project — selecting frameworks, defining coverage thresholds, setting up test infrastructure, and establishing testing patterns. Triggers: new project setup, CI/CD pipeline design, coverage audit, test framework migration, quality standard definition.

Use when drafting prose sections for a bookwright (technical non-fiction) project. Encodes the Bernoulli-textbook workflow: atom-outward design, deferral discipline, running threads, page budgets, Path A subagent pattern, header comment block convention.

Things's UI design system. Use when building interfaces inspired by Things's aesthetic - light mode, Inter font, 8px grid.