Skip to main content
skill CX Codex

responsive-design · mindrally — Claude Code skill: responsive CSS rules for agents

A skill that hands your coding agent a set of responsive design rules: mobile-first CSS, flexible layouts, media queries, adaptive images and type.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Mindrally/skills --skill responsive-design -a claude-code
Open on GitHub

What responsive-design does

The skill is a set of guidelines the agent picks up when it touches markup and styles. It writes semantic HTML, keeps styling in CSS instead of inline attributes, and defines base rules for the narrowest viewport first, then layers complexity on with media queries. For layout it points to Flexbox and CSS Grid, auto-fit with minmax() for grids, and container queries for components that need to react to their own box.

Separate sections cover fluid typography with clamp() and rem, images via srcset and sizes, and a ready breakpoint ladder running from 320px to 1536px. User preferences get their own queries: dark mode, reduced motion, contrast. Touch targets are spelled out at a minimum of 44x44 pixels, and since nobody hovers on a phone, hover states belong inside @media (hover: hover).

Nothing runs and no keys are needed — it is a text file of rules the agent reads. That also means the output depends on whether your model actually follows instructions in a file; weaker models will drop parts of it. You still verify the result yourself, in DevTools, on a real device, in landscape, and at 200% zoom.

What it helps with

  • build a layout that holds up on a narrow screen
  • replace fixed font sizes with clamp() and rem
  • serve the right image resolution through srcset
  • move inline styles out into CSS
  • make buttons comfortable to tap, not just to click

Example prompts for the agent

  • build this product card mobile-first, use the breakpoints from the responsive-design skill
  • audit this CSS for responsiveness and rewrite fixed sizes with clamp()
  • add srcset and sizes to the images in this template

How to install responsive-design

1Skills CLI (Vercel)

npx skills add Mindrally/skills --skill responsive-design -a claude-code

2Manually: put the files in place

~/.claude/skills/responsive-design/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/responsive-design/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about responsive-design

How do I install responsive-design in Claude?

Run npx skills add Mindrally/skills --skill responsive-design -a claude-code. The skill file then lives at ~/.claude/skills/responsive-design/SKILL.md.

What does the responsive-design skill do?

It gives the agent responsive design rules: a mobile-first approach, Flexbox and Grid layouts, media queries, fluid typography and images, and touch target sizing.

Does the skill need any extra tooling?

No, it is plain instructions for the agent. You still check the result in a browser: device emulation in DevTools, a real device, a Lighthouse audit.

Source text

SKILL.md · Apache-2.0
---
name: responsive-design
description: Comprehensive guidelines for responsive web design including mobile-first approach, flexible layouts, media queries, and cross-device optimization
metadata:
  maintainer: Mindrally
  source: https://github.com/Mindrally/skills
---

# Responsive Design Guidelines

## Core Principles

- Write semantic HTML to improve accessibility and SEO
- Use CSS for styling, avoiding inline styles
- Ensure responsive design using media queries and flexible layouts
- Prioritize accessibility by using ARIA roles and attributes
- Design mobile-first, then enhance for larger screens

## Mobile-First Approach

### Strategy
- Start with styles for the smallest viewport
- Add complexity through progressive enhancement
- Base styles work without media queries
- Media queries add features for larger screens

### Benefits
- Forces prioritization of essential content
- Improves performance on mobile devices
- Ensures core functionality works everywhere
- Reduces CSS complexity and specificity issues

```css
/* Base styles for mobile */
.container {
  padding: 1rem;
}

/* Tablet and up */
@media (min-width: 768px) {
  .container {
    padding: 2rem;
  }
}

/* Desktop and up */
@media (min-width: 1024px) {
  .container {
    max-width: 1200px;
    margin: 0 auto;
  }
}
```

## Flexible Layouts

### Flexbox
- Use for one-dimensional layouts (row or column)
- Leverage `flex-wrap` for responsive wrapping
- Use `gap` for consistent spacing
- Combine with media queries for layout changes

### CSS Grid
- Use for two-dimensional layouts
- Leverage `auto-fit` and `auto-fill` for responsive grids
- Use `minmax()` for flexible track sizing
- Combine `fr` units with fixed minimums

```css
.grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
  gap: 1rem;
}
```

### Container Queries
- Style components based on container size, not viewport
- Use for truly reusable components
- Define containers with `container-type`

## Responsive Typography

### Fluid Typography
- Use `clamp()` for responsive font sizes
- Set minimum, preferred, and maximum values
- Avoid text that's too small on mobile or too large on desktop

```css
h1 {
  font-size: clamp(1.5rem, 4vw + 1rem, 3rem);
}
```

### Units
- Use `rem` for scalable typography
- Base `rem` on user's browser settings
- Use `em` for component-relative sizing
- Avoid fixed `px` values for font sizes

## Responsive Images

### Srcset and Sizes
- Use `srcset` for multiple image resolutions
- Use `sizes` to indicate display size at breakpoints
- Let browser choose optimal image

```html
<img
  src="image-800.jpg"
  srcset="image-400.jpg 400w, image-800.jpg 800w, image-1200.jpg 1200w"
  sizes="(max-width: 600px) 100vw, (max-width: 1000px) 50vw, 800px"
  alt="Description"
>
```

### Picture Element
- Use for art direction (different crops at different sizes)
- Provide fallback with `<img>` element
- Use media attributes for breakpoint-specific sources

### Performance
- Include `width` and `height` attributes to prevent layout shift
- Use `loading="lazy"` for below-fold images
- Consider `aspect-ratio` CSS property

## Media Queries

### Common Breakpoints
```css
/* Small phones */
@media (min-width: 320px) { }

/* Large phones */
@media (min-width: 480px) { }

/* Tablets */
@media (min-width: 768px) { }

/* Laptops/Desktops */
@media (min-width: 1024px) { }

/* Large screens */
@media (min-width: 1280px) { }

/* Extra large screens */
@media (min-width: 1536px) { }
```

### Feature Queries
- Use `@supports` for feature detection
- Provide fallbacks for unsupported features
- Test for specific CSS properties

### Preference Queries
- `prefers-color-scheme` for dark/light mode
- `prefers-reduced-motion` for animation preferences
- `prefers-contrast` for contrast preferences

## Touch Targets

### Sizing
- Minimum 44x44 pixels for touch targets
- Provide adequate spacing between targets
- Consider thumb reach zones on mobile

### Interaction
- Don't rely solely on hover states
- Provide touch alternatives for hover interactions
- Use `@media (hover: hover)` for hover-capable devices

## Viewport Configuration

### Meta Tag
```html
<meta name="viewport" content="width=device-width, initial-scale=1">
```

### Best Practices
- Always include viewport meta tag
- Don't disable user scaling (avoid `user-scalable=no`)
- Test with pinch-to-zoom enabled
- Ensure content is usable at 200% zoom

## Testing

### Tools
- Browser DevTools device emulation
- Real device testing when possible
- Lighthouse for performance audits
- W3C validators for code quality

### Checklist
- Test at multiple viewport sizes
- Test landscape and portrait orientations
- Test with touch and mouse input
- Test with keyboard navigation
- Verify images load appropriate sizes
- Check typography readability
- Verify touch targets are adequate
- Test with browser zoom

## Performance Considerations

### Critical CSS
- Inline critical above-fold CSS
- Defer non-critical stylesheets
- Minimize render-blocking resources

### Asset Optimization
- Compress images appropriately
- Use modern formats (WebP, AVIF)
- Lazy load below-fold content
- Consider responsive loading strategies

© Mindrally · Apache-2.0 · Mindrally/skills

Similar skills

Everything for Frontend and UI →

responsive-design by other authors comes first.

responsive-design Seth Hobson Guides responsive UI work with mobile-first styles, container queries, and fluid values. Use it when pages or components need to adapt to available space. CX Codex 20,956installs responsive-design Owl-Listener A skill that steers your coding agent toward layouts and interactions that hold up across screen sizes and input methods. CX Codex +1 2,300installs responsive-design akillness The skill turns a vague “breaks on mobile” report into one named responsive surface, a strategy packet and a verification plan. CX Codex +1 478installs responsive-web-design aj-geddes A skill that steers your coding agent toward mobile-first CSS with Flexbox, Grid and media queries. Useful when one layout has to hold up on phones and desktops. CX Codex +1 1,100installs Frontend Responsive Design Standards am-will A skill that gives your coding agent rules for mobile-first layouts: breakpoints, relative units, touch targets and content priority. CX Codex +1 1,200installs mobile-first-design aj-geddes A skill that sets the order of UI work: design the phone screen first, then scale to tablet and desktop. Useful when layouts break on small devices. CX Codex +1 857installs tailwindcss-advanced-layouts JosiahSiegel Advanced Tailwind CSS layout recipes. Helps you assemble complex CSS Grid structures, container queries, and resilient Flexbox patterns directly in your components. CX Codex +1 8,100installs responsive-craft kylezantos A skill for responsive work: audit an existing site, build a layout from scratch, or open a live preview across breakpoints. CX Codex +1 736installs responsive-design-system patricio0312rev A skill that walks your coding agent through mobile-first layouts: breakpoints, container queries, fluid typography and adaptive grids built on Tailwind CSS. CX Codex +1 343installs

From the same set214

java-quarkus-development Development guidelines for building Quarkus microservices. It directs the coding agent to handle reactive endpoints, Panache data access, and GraalVM native builds. CX Codex +1 836installs elixir A skill that tells your coding agent how to write Elixir and Phoenix: functional patterns, Ecto, LiveView, OTP. Useful when the project actually runs on BEAM. CX Codex +1 836installs nuxtjs-vue-typescript Coding guidelines for Nuxt 3 and Vue 3 projects using TypeScript and Tailwind CSS. Guides component typing, composables, and Nitro server endpoints. CX Codex +1 834installs spring-boot A skill that gives your agent Spring Boot conventions: REST controllers, JUnit tests, security, build and deploy. Useful when the project is Java. CX Codex +1 832installs ghost Gives your agent working knowledge of Ghost CMS theme development: Handlebars templates, partials, Tailwind CSS and Alpine.js wiring, image and SEO work. CX Codex +1 828installs woocommerce Development guidelines for WordPress and WooCommerce. Helps assistants write safe PHP code with hooks, custom product types, and REST endpoints. CX Codex +1 826installs testing Defines software testing guidelines for AI agents, covering test isolation, table-driven checks, and mock boundaries. CX Codex +1 825installs go-backend-microservices A microservices engineering skill for Go projects. It guides coding assistants to apply clean architecture, configure OpenTelemetry, and write table-driven tests. CX Codex +1 823installs

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor