Results for “interfaces”

Golang struct and interface design patterns — composition, embedding, type assertions, type switches, interface segregation, dependency injection via interfaces, struct field tags, and pointer vs value receivers. Use this skill when designing Go types, defining or implementing interfaces, embedding structs or interfaces, writing type assertions or type switches, adding struct field tags for JSON/YAML/DB serialization, or choosing between pointer and value receivers. Also use when the user asks about "accept interfaces, return structs", compile-time interface checks, or composing small interfaces into larger ones.

The English summary is being prepared. Showing the original description.

Organize complex feature work into exploratory prototypes, written behavior contracts, shared tests, and focused pull requests. Use this workflow to settle interfaces before review, split large changes around clear responsibilities, and handle review findings without expanding scope.

• Planning a feature that changes multiple public interfaces
• Resolving interface changes that recur during review
• Splitting a large branch into focused pull requests

Map the impact of a proposed change using real dependencies and project documentation. Identify affected code, data, interfaces, tests, and release steps, then compare the implemented changes with the plan to expose gaps and unverified risks.

• Map callers and tests affected by an API change
• Review database migration and recovery plans
• Check authentication changes across modules

Build complex interactive artifacts for claude.ai with React, Tailwind CSS, and shadcn/ui. Start from a configured project, develop interfaces with state management or navigation, and bundle the result into one shareable HTML file.

• Building interactive interfaces with multiple components
• Creating artifacts with state management and navigation
• Developing interfaces with shadcn/ui components

Build accessible interfaces with shadcn/ui components and Tailwind CSS styling. Create forms, tables, and layouts that adapt to screen size, then coordinate colors, spacing, and dark mode across the application.

• Build forms with keyboard navigation
• Adapt layouts for phones and desktops
• Unify colors and dark mode

Design minimalist web interfaces with warm monochrome colors, clear typographic hierarchy, generous spacing, and flat card grids. Use muted pastel accents and subtle motion to create an editorial layout for product interfaces.

• Prototyping a minimalist product interface
• Organizing feature cards in an asymmetric grid
• Unifying typography, spacing, and colors

Organize Python projects with clear file responsibilities, directory layouts, and public interfaces—the functions and classes intended for other code to use. Covers new projects, existing code reorganization, test placement, package exports, and dependency direction.

• Planning the layout of a new Python project
• Splitting files with unrelated responsibilities
• Defining public interfaces with __all__

Design, implement, or review native Mac interfaces using SwiftUI or AppKit. Organize panes, remove unnecessary containers, and apply restrained Liquid Glass effects while checking resizing, interaction states, and accessibility, including designs supplied through Figma.

• Designing a native Mac app interface
• Reviewing screens with too many cards and borders
• Implementing a Figma design in SwiftUI

Build and update Mastra application interfaces using existing components from @mastra/playground-ui. Follow shared visual styles, arrange layouts with Tailwind utilities, and connect themes and stylesheets while avoiding duplicated components or unsupported appearance overrides.

• Building a new Mastra application screen
• Adjusting layouts with existing components
• Connecting shared themes and stylesheets

Build Laravel applications with authenticated APIs, interactive interfaces, and background jobs. The skill guides database relationships, query optimization, and feature tests, using tools such as Sanctum for authentication and Livewire for interfaces.

• Build an authenticated Laravel API
• Optimize database queries and relationships
• Set up background jobs with Horizon

Builds and updates OpenClaw interfaces using shared styling rules, existing components, and semantic tokens—named values for visual roles. Helps keep themes, controls, and interaction states consistent while preserving application behavior unless changes are requested.

• Styling OpenClaw screens with shared visual rules
• Updating themes and semantic design tokens
• Reviewing focus, loading, and error states

Understand how Airtable organizes data into bases, tables, fields, and records. Learn how views, automations, and interfaces relate to that structure, giving you context for discussing data organization and workflows with an agent.

• Learning Airtable's basic data structure
• Understanding views and interfaces
• Reviewing how automations work

Review architecture changes in Apache Pinot, focusing on module dependencies, extension interfaces, abstractions, and class placement. Use it to examine changes that cross module boundaries or introduce new plugins and interfaces.

• Reviewing classes moved between modules
• Checking new extension interfaces or abstract classes
• Reviewing new plugin directories

Design engineering principles for making interfaces feel polished. Use when building UI components, reviewing frontend code, implementing animations, hover states, shadows, borders, typography, icons, micro-interactions, enter/exit animations, or any visual detail work. Supports quick and full review modes. Triggers on UI polish, design details, "make it feel better", "feels off", stagger animations, border radius, optical alignment, font smoothing, tabular numbers, image outlines, box shadows, icons, icon stroke weight, icon states, motion restraint.

The English summary is being prepared. Showing the original description.

Build interactive web applications using HTML/JavaScript interfaces with MATLAB computational backends via the uihtml component. Use when creating HTML-based MATLAB apps, JavaScript MATLAB interfaces, web UIs with MATLAB, interactive MATLAB GUIs, or when user mentions uihtml, HTML, JavaScript, web apps, or web interfaces.

The English summary is being prepared. Showing the original description.

World-class motion design expertise combining Disney's 12 principles of animation, Material Design's motion system, and the performance-first philosophy of production interfaces. Motion design is the craft of bringing interfaces to life - not through decoration, but through clarity, continuity, and communication. Great motion design is invisible. Users don't notice the animations - they notice that the interface feels natural, responsive, and alive. Every transition tells a story: where did this come from? Where is it going? What just happened? Motion is the language of cause and effect in digital interfaces. Use when "animation, motion, transition, microinteraction, easing, timing, choreography, loading animation, skeleton loader, page transition, hover effect, scroll animation, spring animation, keyframes, framer motion, gsap, lottie, animation, motion, transitions, microinteractions, easing, timing, accessibility, performance, frontend, design" mentioned.

The English summary is being prepared. Showing the original description.

Expert-level neural engineering covering neural interfaces, brain-computer interfaces, neural signal processing, deep brain stimulation, and neuroprosthetics.

The English summary is being prepared. Showing the original description.

Build temporary OpenClaw terminal interfaces with fixed sample data and compare two to six interactive designs side by side in tmux, a terminal pane manager, using the actual rendering components without running the full application.

• Comparing onboarding screen designs
• Trying chat or selector layouts
• Comparing an existing screen with alternatives

Build features or fix bugs by writing one failing test, then the smallest implementation that passes it. Tests check behavior through public interfaces, the entry points callers use, so they remain useful when internal code changes.

• Building a feature one test at a time
• Fixing a bug with a failing test first
• Planning integration tests at agreed public interfaces

Turn product requests and planning documents into a concrete development plan. Document business rules, data ownership, service interfaces, and unresolved decisions so teams can see what must be settled before implementation begins.

• Turning a product requirements document into development requirements
• Aligning requirements for a feature spanning multiple services
• Documenting assumptions that repeatedly surface in reviews

Refine interface appearance and interactions by reviewing spacing, typography, rounded corners, shadows, animation, and clickable areas. Get concrete before-and-after recommendations for buttons, cards, forms, and other components, including hover, focus, and loading states.

• Review screens that feel cramped or unfinished
• Refine buttons, cards, and forms
• Improve hover, focus, and loading states

Write, review, and refactor Go applications using established language conventions. The skill covers error handling, concurrent tasks, interfaces, package structure, memory use, and development commands to support clear, maintainable code.

• Reviewing Go code for established conventions
• Improving error handling in existing code
• Designing concurrent tasks with cancellation

Build MCP servers that let AI access actions and data using mcp-use. The guide covers project setup, reusable prompts, interactive React interfaces, authentication, error handling, and deployment, with reference files for each area.

• Create a new MCP server with mcp-use
• Add actions, data resources, or reusable prompts
• Build interactive React interfaces for browsing and selection

Search local design guidance to plan, build, review, or improve web, mobile, and desktop interfaces. Find suitable colors, font pairings, layouts, charts, and interaction patterns, with implementation advice matched to the project's technology.

• Choose colors and fonts for a new product
• Review forms and keyboard accessibility
• Fix layouts that break on small screens