MCPInstall

frontend-design

Create distinctive React and Tailwind interfaces with strong hierarchy and polished implementation. Use when building or redesigning pages, flows, or components, or when another better-react-web-ui skill needs shared design guidance. Pair with add-ui for direct implementation or requested alternatives.

Installs
65
Last 24h
—
Trending rank
—
Security
Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/aladicf/better-react-web-ui --skill frontend-design
  1. 01

    Install

    Run the command in your project. The CLI asks which agents to install for.

  2. 02

    Describe the task

    Ask your agent for something this skill covers. It loads frontend-design automatically when relevant.

  3. 03

    Review the result

    The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

Create working React and Tailwind interfaces that fit the product, preserve explicit constraints, and make the primary task clear. Read only the references relevant to the requested work.

Match the requested scope

For advice, comparison of workflows, or questions about which skill to use, answer without executing those skills. Do not edit files, persist context, create reports, or start an interview. For an explicit review, inspect and report. Implement fixes only when the user requests them or has already authorized them. Reuse prior authorization within its scope.

Context Gathering Protocol

Gather only the context needed for the requested decision. Use this order:

  1. Reuse the user's current instructions, prior answers, and any direction or creative authority already granted.
  2. Resolve the target application's context using project context. Read its .better-react-web-ui.md, applicable parent defaults, matching page brief, and existing design documents. Legacy files are fallback inputs within the same scope.
  3. Inspect the affected code, callers, assets, and existing design system. Treat observed implementation as evidence of the current system, not proof of unstated audience needs.
  4. Ask only about missing facts that materially change the work. Label reasonable assumptions and proceed with reversible choices within the authorized scope.

For a new design direction, establish the audience, intended task, and brand tone. Under explicit creative delegation, choose and record reasonable assumptions without another approval checkpoint. Never invent user answers or product facts.

For a focused repair, use the relevant code and constraints. Do not require a brand interview before fixing keyboard focus, overflow, or a measured performance defect.

Use $setup when the user requests persistent project context or when substantial design work needs missing context recorded. The absence of a context file alone does not require setup. Preserve existing context when updating it.

Set priorities

Preserve the existing visual system unless the user requests a change. For an open direction, choose a coherent style through design directions. Establish hierarchy with spacing, grouping, type, and contrast before adding decoration.

Distinguish requirements from preferences:

  • Preserve accessibility, truthful content, functional controls, and explicit user constraints.
  • Treat aesthetic guidance as defaults for open decisions. Inter, Arial, system fonts, pure white, pure black, gradients, cards, and familiar layouts are valid when they fit the brand and task.
  • Use AI slop detection to diagnose generic composition, unsupported claims, or unnecessary decoration. A font or color alone is not a defect.
  • Keep core workflows familiar and readable even when the marketing page uses expressive imagery or motion.

Prioritize clarity, task completion, and error prevention over visual novelty. Never fabricate customers, testimonials, metrics, capabilities, urgency, or scarcity. Keep prices, consent, destructive consequences, and cancellation paths clear. See interface honesty.

Match the implementation

Detect the existing React framework, Tailwind configuration, components, tokens, and data flow before editing. Reuse suitable code and installed dependencies. Respect explicit stack choices for new projects. Use framework defaults only for unspecified choices.

Consult framework official docs before framework-specific decisions. For Next.js, read relevant bundled documentation at node_modules/next/dist/docs/ when available. Prefer that version-matched source over memory.

Use component and block strategy and React shadcn accelerators when existing components or blocks fit the task. For custom primitives, read component anatomy and component accessibility. Preserve mature library semantics rather than rewriting them for appearance.

In Astro projects, add React islands only for interactions that need them. Keep implementation complexity proportionate to the requested result.

Implement the requested result

  1. Identify the target page, flow, or component and the visitor's task on that page. Preserve fixed content, section order, and interaction behavior. For substantial work, reuse or prepare the optional page brief described in project context.
  2. Choose a direction within the user's authority. For one requested artifact, implement directly. Use $add-ui for comparison when the user asks for alternatives, honoring the requested count. Do not add a selection checkpoint after the user has chosen or delegated a direction.
  3. Build the smallest complete version with real source files and working actions. Establish a constrained spacing, type, color, radius, and elevation system before decorative details. When following an approved visual reference, use reference fidelity.
  4. Cover relevant loading, empty, error, success, and responsive states. Use optimistic updates only when failures can be recovered without misleading the user or losing data.
  5. Verify the result in the target project. Report what changed, the checks performed, and any untested behavior.

For substantial missing context, use design process and UX strategy. Do not turn a focused repair into a redesign.

Load references by task

TaskReferences
Landing or marketing pageLanding-page storytelling, hero sections, marketing copywriting, social proof
Hierarchy and layoutHierarchy checklist, spacing system, spatial design
TypographyTypography, text hierarchy and readability
Color and statusColor and contrast, semantic color, colorblindness UX
Imagery and depthImage treatment, surface separation, elevation system
Animation or scrollingMotion design, landing-page storytelling
Responsive behaviorResponsive design, container queries
Controls, forms, and recoveryInteraction design, component accessibility, error recovery
Copy and product decisionsUX writing, interface honesty, pricing and packaging
Final reviewReact and Tailwind implementation review, before-and-after examples

Use the reference index for specialized topics such as authentication, commerce, data visualization, onboarding, permissions, and localization. Do not load the entire reference library for every task.

Verify before delivery

Follow visual verification for evidence, fix status, and unavailable-tool handling. Scale the following checks to the affected feature.

  • Check that the primary action is clear and functional. Keep labels and content truthful.
  • Check desktop and phone layouts, long content, and zoom for clipping, overflow, and lost functionality.
  • Test keyboard operation, visible focus, accessible names, contrast, and relevant error recovery.
  • With reduced motion enabled, keep all meaningful content visible and reachable. Decorative animation must not gate content access.
  • Load initially visible and likely LCP images eagerly. Lazy-load suitable below-fold media. Reserve dimensions to avoid layout shifts.
  • Base performance findings on measurements. Add memoization or temporary will-change only when profiling supports it.
  • Use the project's existing checks and respect its command restrictions. Do not claim browser, accessibility, or performance results from source inspection alone.
  • Review whether typography, spacing, color, and interaction decisions fit the product. Preserve approved brand choices even when a different style is your personal preference.

FAQ

What does the frontend-design skill do?

Create distinctive React and Tailwind interfaces with strong hierarchy and polished implementation. Use when building or redesigning pages, flows, or components, or when another better-react-web-ui skill needs shared design guidance. Pair with add-ui for direct implementation or requested alternatives.

How do I install frontend-design?

Run npx skills add https://github.com/aladicf/better-react-web-ui --skill frontend-design in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/frontend-design/ (personal) or .claude/skills/frontend-design/ (project).

Which AI agents can use frontend-design?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is frontend-design safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains frontend-design?

It is published by aladicf in aladicf/better-react-web-ui. It has 65 recorded installs.

More from aladicf/better-react-web-ui

View all →

polish

aladicf/better-react-web-ui

Perform a final quality pass fixing alignment, spacing, consistency, and micro-detail issues before shipping. Use when the work is functionally complete and needs finishing touches—not when the hierarchy, structure, tone, or technical foundation still need major changes.

add-ui

aladicf/better-react-web-ui

Create or redesign React and Tailwind sections, pages, flows, shells, and components. Use when the user wants new UI or a redesign. Implement one requested or selected direction directly, or generate distinct alternatives when the user asks to compare options.

setup

aladicf/better-react-web-ui

Open the skill to read its SKILL.md instructions.

forms

aladicf/better-react-web-ui

Open the skill to read its SKILL.md instructions.

data-viz

aladicf/better-react-web-ui

Design charts, metrics, and data tables that help users interpret and compare data. Use when the user asks to visualize data, choose chart types, improve dashboard analytics, or make data presentation accessible. Dashboard navigation and shell layout alone belong to add-ui or arrange.

colorize

aladicf/better-react-web-ui

Open the skill to read its SKILL.md instructions.

Popular frontend & design skills

View category →

setup-matt-pocock-skills

mattpocock/skills

Configure this repo for the engineering skills: set up its issue tracker, triage label vocabulary, and domain doc layout. Run once before first use of the other engineering skills.

Frontend & Design1.1M installs

frontend-design

anthropics/skills

Guidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.

OfficialFrontend & Design1M installs

hyperframes-animation

heygen-com/hyperframes

All animation knowledge for HyperFrames — atomic motion rules, multi-phase scene blueprints, scene transitions, broader motion-design techniques, AND the seven runtime adapters (GSAP default, plus Lottie, Three.js, Anime.js, CSS keyframes, Web Animations API, TypeGPU). Use for any motion or animation task: pick 2-4 rules and compose, or load a blueprint, or look up runtime-specific API (e.g. GSAP eases / Lottie player / Three.js mixer). Also covers auditing an existing composition's choreography (animation map) and 24 named text-animation effects. HyperFrames-native: single paused timeline, seek-safe, deterministic.

prototype

mattpocock/skills

Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.

Frontend & Design999.2K installs

hyperframes-core

heygen-com/hyperframes

The HyperFrames composition contract — build one renderable project. Use for composition structure, the data- timing attributes, class="clip", tracks, sub-compositions, variables, framework-owned media playback, deterministic-render rules, and validation. Read before writing composition HTML.

Frontend & Design930.5K installs

vercel-react-best-practices

vercel-labs/agent-skills

React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.

OfficialFrontend & Design843.1K installs