frontend-design-review

dauquangthanh/hanoi-rainbow · updated Apr 26, 2026

MDX-style export adds YAML metadata + attribution linking explainx.ai and this canonical listing URL.

$npx skills add https://github.com/dauquangthanh/hanoi-rainbow --skill frontend-design-review
0 commentsdiscussion
summary

This skill provides expert guidance for conducting thorough frontend design reviews, covering UI/UX design quality, design system consistency, accessibility compliance, and responsive design patterns. The skill helps identify design issues early in the development lifecycle, ensuring designs meet quality standards, accessibility requirements, and business objectives before implementation.

skill.md

Frontend Design Review

Overview

This skill provides expert guidance for conducting thorough frontend design reviews, covering UI/UX design quality, design system consistency, accessibility compliance, and responsive design patterns. The skill helps identify design issues early in the development lifecycle, ensuring designs meet quality standards, accessibility requirements, and business objectives before implementation.

Core Capabilities

1. UI/UX Design Quality Review

  • Visual design assessment (typography, color, spacing, layout, visual hierarchy)
  • User experience evaluation (flows, interactions, navigation, usability)
  • Design consistency verification across screens and journeys
  • Brand alignment and visual identity validation
  • Cognitive load analysis

2. Design System Validation

  • Component library review (design, variants, states, reusability)
  • Design tokens validation (colors, typography, spacing)
  • Pattern library assessment for consistency
  • Documentation quality evaluation
  • Design system governance assessment

3. Accessibility Compliance

  • WCAG 2.1 AA compliance verification
  • Color contrast validation (4.5:1 text, 3:1 UI components)
  • Keyboard navigation and focus management
  • Screen reader support validation
  • Accessible interaction patterns review

4. Responsive Design Review

  • Breakpoint strategy evaluation
  • Mobile-first approach assessment
  • Touch target sizing verification (44x44px minimum)
  • Content adaptation across viewports
  • Performance considerations

5. Component Architecture Assessment

  • Component hierarchy and composition patterns
  • Reusability and flexibility evaluation
  • State management review (default, hover, active, disabled, error, loading)
  • Component variants and customization patterns
  • Component documentation quality

Workflow

Phase 1: Pre-Review Preparation

1. Gather Design Assets

  • Collect Figma/Sketch files, design specifications, mockups
  • Obtain design system documentation and component library
  • Review brand guidelines and style guides
  • Gather user research findings and personas

2. Understand Context

  • Review project requirements and business objectives
  • Understand target users and use cases
  • Identify key user journeys and critical flows
  • Note technical constraints and platform requirements

3. Define Review Scope

  • Identify screens/flows to review
  • Determine review depth (high-level vs. detailed)
  • Set priorities based on importance
  • Establish timeline and deliverables

Phase 2: Conduct Design Review

Step 1: Visual Design Review

  • Assess typography (font selection, type scale, line heights, consistency)
  • Evaluate color system (palette, contrast, semantic usage, tokens)
  • Review spacing and layout (grid system, whitespace, alignment)
  • Check visual hierarchy (size, color, position, emphasis)
  • Validate iconography (style, size, clarity, consistency)
  • Assess imagery and media (quality, aspect ratios, optimization)

Step 2: Design System Compliance

  • Verify component usage matches design system
  • Check for design token usage (no hard-coded values)
  • Identify deviations from established patterns
  • Validate component variants and states
  • Review custom components vs. system components

Step 3: Accessibility Audit

  • Test color contrast ratios for all text and UI elements
  • Verify keyboard navigation and tab order
  • Check focus indicators visibility and clarity
  • Validate ARIA labels and semantic structure
  • Review alternative text for images
  • Assess form label associations
  • Test interactive element accessibility

Step 4: Responsive Design Evaluation

  • Review breakpoint strategy (mobile, tablet, desktop)
  • Check content adaptation at different viewports
  • Verify touch target sizes on mobile
  • Assess navigation patterns for mobile
  • Review image responsiveness and optimization
  • Validate typography scaling across devices

Step 5: Component Architecture Analysis

  • Evaluate component organization and hierarchy
  • Review component reusability and composition
  • Check component state coverage
  • Assess variant design and flexibility
  • Validate component props and customization

Step 6: User Experience Assessment

  • Analyze user flows and task completion paths
  • Evaluate navigation structure and findability
  • Check interaction patterns and feedback
  • Assess error states and error handling
  • Review empty states and loading states
  • Validate form design and validation patterns

Phase 3: Document Findings

1. Categorize Issues by Severity

  • Critical: Blocking issues, must fix before launch
  • High: Significant usability/accessibility issues
  • Medium: Issues with workarounds, should fix soon
  • Low: Minor polish, nice-to-haves

2. Create Detailed Findings Report See design-review-report-template.md for comprehensive report structure

Include:

  • Executive summary with key statistics
  • Review scope documentation
  • Findings by category with specific examples
  • Severity-rated issue list
  • Positive observations (what's working well)
  • Actionable recommendations with priorities
  • Action items with owners and timelines

3. Provide Visual Examples

  • Screenshot issues with annotations
  • Show before/after for recommendations
  • Include contrast ratio measurements
  • Document component state issues visually

Phase 4: Collaborate on Solutions

1. Prioritize Fixes

  • Separate must-fix from nice-to-have
  • Consider implementation effort
  • Balance user impact with development cost

2. Create Action Plan

  • Assign owners (design team vs. development team)
  • Set realistic timelines
  • Schedule follow-up review

3. Document Decisions

  • Record accepted risks or trade-offs
  • Note items deferred to future work
  • Update design system if patterns change

Severity Level Guidelines

Critical (Blocking)

  • Violates WCAG AA requirements (legal risk)
  • Completely blocks core user tasks
  • Causes data loss or security issues
  • Severely damages brand or user trust

High Priority

  • Significantly degrades user experience
  • Impacts large number of users
  • Creates major accessibility barriers
  • Inconsistent with design system causing confusion

Medium Priority

  • Negatively impacts experience but has workarounds
  • Affects subset of users
  • Minor accessibility issues (WCAG AAA)
  • Design inconsistencies that are noticeable

Low Priority

  • Polish and optimization items
  • Edge case issues
  • Minor visual refinements
  • Nice-to-have enhancements

Accessibility Quick Reference

WCAG 2.1 AA Requirements:

  • Color contrast: 4.5:1 for normal text, 3:1 for large text (18pt+ or 14pt+ bold)
  • UI component contrast: 3:1 minimum
  • Keyboard accessible: All functionality available via keyboard
  • Focus visible: Clear focus indicators on interactive elements
  • Text alternatives: All images have appropriate alt text
  • Form labels: All inputs have associated labels
  • Semantic HTML: Proper heading hierarchy and landmarks
  • Touch targets: 44x44 CSS pixels minimum

Testing Tools:

  • Color contrast: WebAIM Contrast Checker, Stark plugin
  • Keyboard nav: Manual testing with Tab/Shift+Tab
  • Screen reader: Test with VoiceOver (Mac), NVDA (Windows)

Design System Review Checklist

Component Usage:

  • All components sourced from design system
  • No one-off custom variations without justification
  • Component variants used appropriately
  • All component states designed (default, hover, active, disabled, error, loading)

Design Tokens:

  • Colors use token references (not hex values)
  • Typography uses token references (not hard-coded sizes)
  • Spacing uses token references (8px grid system)
  • Shadows and effects use token references

Patterns:

  • Navigation patterns consistent with system
  • Form patterns follow system conventions
  • Modal/dialog patterns match system
  • Empty states use system patterns
  • Error handling follows system patterns

Reference Files

Load these references based on specific review needs:

Example Review Flow

Scenario: Reviewing a new checkout flow design in Figma

  1. Preparation (30 min)

    • Review checkout requirements and success metrics
    • Identify 5 screens in checkout flow
    • Gather payment compliance requirements
    • Review design system component library
  2. Visual Design Review (45 min)

    • Check typography consistency across all 5 screens
    • Verify color contrast on CTA buttons (found 2 issues)
    • Validate spacing follows 8px grid
    • Review visual hierarchy on payment screen
  3. Accessibility Audit (60 min)

    • Test color contrast: 3 text elements fail (4.2:1, need 4.5:1)
    • Check keyboard flow: Tab order jumps incorrectly on screen 3
    • Verify ARIA labels: Payment input missing label association
    • Review error states: Error messages lack semantic markup
  4. Responsive Review (30 min)

    • Check mobile breakpoint: Form inputs too small (38px height)
    • Verify tablet layout: Good adaptation
    • Test content reflow: Success
  5. Design System Check (20 min)

    • Found custom button variant not in system
    • Spacing uses hard-coded values instead of tokens
    • Form patterns match system conventions ✅
  6. Document Findings (45 min)

    • 3 Critical issues: Contrast failures, touch target sizes
    • 5 High issues: Keyboard navigation, missing labels
    • 4 Medium issues: Design token usage, custom components
    • Create report using template with visual examples
  7. Deliverables

    • Design review report with 12 findings
    • Annotated Figma comments on specific issues
    • Prioritized action items with owners
    • Schedule follow-up review in 1 week

Total Time: ~3.5 hours for comprehensive review

Tips for Effective Reviews

Be Specific: Don't say "improve contrast". Say "Body text on blue background has 3.8:1 contrast, needs 4.5:1. Darken text to #1a1a1a or lighten background."

Show Examples: Include screenshots with annotations. Show the issue and suggest visual fixes.

Prioritize: Clearly separate must-fix from nice-to-have. Focus on user impact.

Provide Context: Explain why an issue matters. "This contrast failure affects 8% of users with low vision."

Be Constructive: Acknowledge what works well. Balance criticism with recognition.

Collaborate: Review findings with designers before finalizing. Get their input on solutions.

Follow Up: Schedule re-review to verify fixes. Track issues to completion.

how to use frontend-design-review

How to use frontend-design-review on Cursor

AI-first code editor with Composer

1

Prerequisites

Before installing skills in Cursor, ensure your development environment meets these requirements:

  • Cursor installed and configured on your development machine
  • Node.js version 16.0+ with npm package manager (verify with node --version)
  • Active project directory or workspace where you want to add frontend-design-review
2

Execute installation command

Execute the skills CLI command in your project's root directory to begin installation:

$npx skills add https://github.com/dauquangthanh/hanoi-rainbow --skill frontend-design-review

The skills CLI fetches frontend-design-review from GitHub repository dauquangthanh/hanoi-rainbow and configures it for Cursor.

3

Select Cursor when prompted

The CLI will show a list of available agents. Use arrow keys to navigate and space to select Cursor:

◆ Which agents do you want to install to?
│ ── Universal (.agents/skills) ── always included ────
│ • Amp
│ • Antigravity
│ • Cline
│ • Codex
│ ●Cursor(selected)
│ • Cursor
│ • Windsurf
4

Verify installation

Confirm successful installation by checking the skill directory location:

.cursor/skills/frontend-design-review

Reload or restart Cursor to activate frontend-design-review. Access the skill through slash commands (e.g., /frontend-design-review) or your agent's skill management interface.

Security & Verification Notice

We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.

Skills execute code in your development environment. Always verify the publisher's identity, review recent commits, and test in isolated environments before production deployment.

List & Monetize Your Skill

Submit your Claude Code skill and start earning

GET_STARTED →

Use Cases

Task Automation & Efficiency

Automate repetitive workflows and reduce manual effort

Example

Generate reports, summarize documents, draft communications

Save 3-5 hours per week on routine tasks

Knowledge Enhancement

Learn new skills, understand complex topics, get expert guidance

Example

Explain concepts, provide examples, suggest learning resources

Accelerate learning and skill development by 2x

Quality Improvement

Enhance output quality through reviews, suggestions, and refinements

Example

Review drafts, suggest improvements, catch errors

Improve work quality by 30-40% with less effort

Implementation Guide

Prerequisites

  • Claude Desktop or compatible AI client with skill support
  • Clear understanding of task or problem to solve
  • Willingness to iterate and refine outputs

Time Estimate

15-45 minutes depending on use case complexity

Installation Steps

  1. 1.Install skill using provided installation command
  2. 2.Test with simple use case relevant to your work
  3. 3.Evaluate output quality and relevance
  4. 4.Iterate on prompts to improve results
  5. 5.Integrate into regular workflow if valuable

Common Pitfalls

  • Expecting perfect results without iteration
  • Not providing enough context in prompts
  • Using skill for tasks outside its intended scope
  • Accepting outputs without review and validation

Best Practices

✓ Do

  • +Start with clear, specific prompts
  • +Provide relevant context and constraints
  • +Review and refine all outputs before using
  • +Iterate to improve output quality
  • +Document successful prompt patterns

✗ Don't

  • Don't use without understanding skill limitations
  • Don't skip validation of outputs
  • Don't share sensitive information in prompts
  • Don't expect skill to replace human judgment

💡 Pro Tips

  • Be specific about desired format and style
  • Ask for multiple options to choose from
  • Request explanations to understand reasoning
  • Combine AI efficiency with human expertise

When to Use This

✓ Use When

Use when skill capabilities match your task, clear ROI on time saved, and you can validate outputs. Best for repetitive tasks, learning, and quality improvement.

✗ Avoid When

Avoid when task requires deep expertise you can't validate, involves sensitive decisions, or when learning process is more valuable than speed of completion.

Learning Path

  1. 1Familiarize yourself with skill capabilities and limitations
  2. 2Start with low-risk, non-critical tasks
  3. 3Progress to more complex and valuable use cases
  4. 4Build expertise through regular use and experimentation

Discussion

Product Hunt–style comments (not star reviews)
  • No comments yet — start the thread.
general reviews

Ratings

4.769 reviews
  • Alexander Park· Dec 20, 2024

    Solid pick for teams standardizing on skills: frontend-design-review is focused, and the summary matches what you get after install.

  • Charlotte Thomas· Dec 20, 2024

    We added frontend-design-review from the explainx registry; install was straightforward and the SKILL.md answered most questions upfront.

  • Alexander Yang· Dec 16, 2024

    frontend-design-review fits our agent workflows well — practical, well scoped, and easy to wire into existing repos.

  • Shikha Mishra· Dec 12, 2024

    frontend-design-review has been reliable in day-to-day use. Documentation quality is above average for community skills.

  • Dev Taylor· Dec 12, 2024

    Registry listing for frontend-design-review matched our evaluation — installs cleanly and behaves as described in the markdown.

  • Dev Menon· Dec 12, 2024

    Solid pick for teams standardizing on skills: frontend-design-review is focused, and the summary matches what you get after install.

  • Emma Choi· Nov 27, 2024

    Solid pick for teams standardizing on skills: frontend-design-review is focused, and the summary matches what you get after install.

  • Emma Reddy· Nov 11, 2024

    frontend-design-review fits our agent workflows well — practical, well scoped, and easy to wire into existing repos.

  • Alexander Abbas· Nov 7, 2024

    We added frontend-design-review from the explainx registry; install was straightforward and the SKILL.md answered most questions upfront.

  • Yash Thakker· Nov 3, 2024

    Keeps context tight: frontend-design-review is the kind of skill you can hand to a new teammate without a long onboarding doc.

showing 1-10 of 69

1 / 7