Skip to content

thedaviddias/Front-End-Checklist / skills/css-minification

css-minification

Verified

Use when reviewing stylesheets, component styles, and responsive behavior related to Minify all CSS files. Check the rendered layout across breakpoints and interaction states before proposing a fix.

FileKindSize
SKILL.mdskill md1.6 KB
references/rule.mdmarkdown16.4 KB

references/rule.md

View on GitHub
# Minify all CSS files

> All CSS files are minified to reduce file size and improve page load performance.

**Priority:** high · **Difficulty:** beginner · **Time:** 15 min

---
CSS minification removes unnecessary characters like whitespace, comments, and redundant code to reduce file sizes and improve loading performance.

## Code Examples

### Unminified CSS (Development)
```css
/* Main navigation styles */
.navigation {
    display: flex;
    justify-content: space-between;
    align-items: center;
    background-color: #ffffff;
    padding: 1rem 2rem;
    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}

.navigation ul {
    display: flex;
    list-style: none;
    margin: 0;
    padding: 0;
    gap: 2rem;
}

.navigation li a {
    color: #333333;
    text-decoration: none;
    font-weight: 500;
    transition: color 0.3s ease;
}

.navigation li a:hover {
    color: #007bff;
}

/* Responsive design */
@media (max-width: 768px) {
    .navigation {
        flex-direction: column;
        padding: 1rem;
    }

    .navigation ul {
        margin-top: 1rem;
    }
}
```

### Minified CSS (Production)
```css
.navigation{display:flex;justify-content:space-between;align-items:center;background-color:#fff;padding:1rem 2rem;box-shadow:0 2px 4px rgba(0,0,0,.1)}.navigation ul{display:flex;list-style:none;margin:0;padding:0;gap:2rem}.navigation li a{color:#333;text-decoration:none;font-weight:500;transition:color .3s ease}.navigation li a:hover{color:#007bff}@media (max-width:768px){.navigation{flex-direction:column;padding:1rem}.navigation ul{margin-top:1rem}}
```

**Size Reduction**: ~65% smaller (from ~600 bytes to ~215 bytes)

## Why It Matters

Unminified CSS wastes bandwidth with whitespace, comments, and verbose syntax—minification delivers the same styles in significantly fewer bytes.

## Build Tool Integration

### Webpack with CSS Minification
```javascript
// webpack.config.js
const MiniCssExtractPlugin = require('mini-css-extract-plugin')
const CssMinimizerPlugin = require('css-minimizer-webpack-plugin')

module.exports = {
  mode: 'production',

  module: {
    rules: [
      {
        test: /\.css$/i,
        use: [
          MiniCssExtractPlugin.loader,
          'css-loader',
          'postcss-loader'
        ]
      }
    ]
  },

  plugins: [
    new MiniCssExtractPlugin({
      filename: '[name].[contenthash].css',
      chunkFilename: '[id].[contenthash].css'
    })
  ],

  optimization: {
    minimize: true,
    minimizer: [
      new CssMinimizerPlugin({
        minimizerOptions: {
          preset: [
            'default',
            {
              discardComments: { removeAll: true },
              normalizeWhitespace: true,
              colormin: true,
              convertValues: true,
              discardDuplicates: true
            }
          ]
        }
      })
    ]
  }
}
```

### Vite CSS Minification
```javascript
// vite.config.js

  build: {
    cssMinify: 'lightningcss', // or 'esbuild'

    rollupOptions: {
      output: {
        assetFileNames: (assetInfo) => {
          const info = assetInfo.name.split('.')
          const ext = info[info.length - 1]
          if (/png|jpe?g|svg|gif|tiff|bmp|ico/i.test(ext)) {
            return `images/[name]-[hash][extname]`
          }
          if (/css/i.test(ext)) {
            return `css/[name]-[hash][extname]`
          }
          return `assets/[name]-[hash][extname]`
        }
      }
    }
  },

  css: {
    postcss: {
      plugins: [
        require('autoprefixer'),
        require('cssnano')({
          preset: 'default'
        })
      ]
    }
  }
})
```

### PostCSS with cssnano
```javascript
// postcss.config.js
module.exports = {
  plugins: [
    require('autoprefixer'),
    ...(process.env.NODE_ENV === 'production' ? [
      require('cssnano')({
        preset: [
          'advanced',
          {
            discardComments: {
              removeAll: true
            },
            normalizeWhitespace: true,
            colormin: true,
            convertValues: true,
            discardDuplicates: true,
            discardEmpty: true,
            mergeRules: true,
            minifySelectors: true,
            reduceInitial: true,
            reduceTransforms: true
          }
        ]
      })
    ] : [])
  ]
}
```

## Framework Examples

### Next.js Automatic Minification
```javascript
// next.config.js
/** @type {import('next').NextConfig} */
const nextConfig = {
  // Next.js automatically minifies CSS in production
  experimental: {
    optimizeCss: true, // Enhanced CSS optimization
  },

  compiler: {
    // Remove console logs in production
    removeConsole: process.env.NODE_ENV === 'production',
  },

  webpack: (config, { dev, isServer }) => {
    if (!dev && !isServer) {
      // Additional CSS optimization for production
      config.optimization.splitChunks.cacheGroups.styles = {
        name: 'styles',
        test: /\.(css|scss|sass)$/,
        chunks: 'all',
        enforce: true
      }
    }

    return config
  }
}

module.exports = nextConfig
```

### Create React App Minification
```javascript
// craco.config.js (for customizing CRA)
const CracoLessPlugin = require('craco-less')

module.exports = {
  plugins: [
    {
      plugin: CracoLessPlugin,
      options: {
        lessLoaderOptions: {
          lessOptions: {
            modifyVars: {
              '@primary-color': '#1DA57A',
            },
            javascriptEnabled: true,
          }
        },

        miniCssExtractPluginOptions: {
          ignoreOrder: true,
        },

        postcssLoaderOptions: {
          postcssOptions: {
            plugins: [
              require('autoprefixer'),
              ...(process.env.NODE_ENV === 'production' ? [
                require('cssnano')({
                  preset: 'default'
                })
              ] : [])
            ]
          }
        }
      }
    }
  ]
}
```

### Vue.js CSS Minification
```javascript
// vue.config.js
module.exports = {
  css: {
    extract: process.env.NODE_ENV === 'production' ? {
      filename: 'css/[name].[contenthash:8].css',
      chunkFilename: 'css/[name].[contenthash:8].css'
    } : false,

    sourceMap: process.env.NODE_ENV !== 'production'
  },

  configureWebpack: config => {
    if (process.env.NODE_ENV === 'production') {
      // CSS optimization for production
      config.optimization.splitChunks.cacheGroups.styles = {
        name: 'styles',
        test: /\.(css|vue)$/,
        chunks: 'all',
        enforce: true
      }
    }
  },

  chainWebpack: config => {
    if (process.env.NODE_ENV === 'production') {
      config.plugin('extract-css')
        .use(require('mini-css-extract-plugin'), [{
          filename: 'css/[name].[contenthash:8].css',
          chunkFilename: 'css/[name].[contenthash:8].css'
        }])
    }
  }
}
```

## CSS-in-JS Minification

### Styled Components with Minification
```jsx

// The styled-components babel plugin automatically minifies in production
const Navigation = styled.nav`
  display: flex;
  justify-content: space-between;
  align-items: center;
  background-color: white;
  padding: 1rem 2rem;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);

  ul {
    display: flex;
    list-style: none;
    margin: 0;
    padding: 0;
    gap: 2rem;
  }

  li a {
    color: #333;
    text-decoration: none;
    font-weight: 500;
    transition: color 0.3s ease;

    &:hover {
      color: #007bff;
    }
  }

  @media (max-width: 768px) {
    flex-direction: column;
    padding: 1rem;

    ul {
      margin-top: 1rem;
    }
  }
`

// babel-plugin-styled-components config in .babelrc
{
  "plugins": [
    ["babel-plugin-styled-components", {
      "minify": true,
      "displayName": false,
      "fileName": false
    }]
  ]
}
```

### Emotion with Production Optimization
```jsx

// Emotion automatically optimizes in production
const navigationStyles = css`
  display: flex;
  justify-content: space-between;
  align-items: center;
  background-color: white;
  padding: 1rem 2rem;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
`

const NavigationList = styled.ul`
  display: flex;
  list-style: none;
  margin: 0;
  padding: 0;
  gap: 2rem;
`

// webpack.config.js for Emotion optimization
module.exports = {
  mode: 'production',
  plugins: [
    new webpack.DefinePlugin({
      'process.env.NODE_ENV': JSON.stringify('production')
    })
  ]
}
```

## Manual Minification Tools

### Command Line Tools
```bash
# Using cssnano CLI
npm install -g cssnano-cli
cssnano src/styles.css dist/styles.min.css

# Using clean-css CLI
npm install -g clean-css-cli
cleancss -o dist/styles.min.css src/styles.css

# Using PostCSS CLI with cssnano
npm install -g postcss-cli cssnano
postcss src/styles.css --use cssnano --output dist/styles.min.css

# Batch processing multiple files
find src/css -name "*.css" -exec cleancss {} \; > dist/bundle.min.css
```

### Node.js Scripts
```javascript
// scripts/minify-css.js
const fs = require('fs')
const path = require('path')
const postcss = require('postcss')
const cssnano = require('cssnano')

async function minifyCSS(inputPath, outputPath) {
  try {
    const css = fs.readFileSync(inputPath, 'utf8')

    const result = await postcss([
      cssnano({
        preset: [
          'advanced',
          {
            discardComments: { removeAll: true },
            normalizeWhitespace: true,
            colormin: true,
            convertValues: true,
            discardDuplicates: true,
            mergeRules: true,
            minifySelectors: true
          }
        ]
      })
    ]).process(css, { from: inputPath, to: outputPath })

    fs.writeFileSync(outputPath, result.css)

    const originalSize = Buffer.byteLength(css, 'utf8')
    const minifiedSize = Buffer.byteLength(result.css, 'utf8')
    const savings = ((originalSize - minifiedSize) / originalSize * 100).toFixed(1)

    console.log(`✅ ${inputPath} → ${outputPath}`)
    console.log(`   ${originalSize} bytes → ${minifiedSize} bytes (${savings}% smaller)`)

  } catch (error) {
    console.error(`❌ Error minifying ${inputPath}:`, error)
  }
}

// Process all CSS files in src directory
async function minifyAllCSS() {
  const srcDir = 'src/css'
  const distDir = 'dist/css'

  if (!fs.existsSync(distDir)) {
    fs.mkdirSync(distDir, { recursive: true })
  }

  const cssFiles = fs.readdirSync(srcDir)
    .filter(file => file.endsWith('.css'))

  for (const file of cssFiles) {
    const inputPath = path.join(srcDir, file)
    const outputPath = path.join(distDir, file.replace('.css', '.min.css'))
    await minifyCSS(inputPath, outputPath)
  }
}

minifyAllCSS()
```

## Advanced Optimization Techniques

### Critical CSS Extraction and Minification
```javascript
// scripts/optimize-critical-css.js
const critical = require('critical')
const postcss = require('postcss')
const cssnano = require('cssnano')

async function optimizeCriticalCSS() {
  // Extract critical CSS
  const { css } = await critical.generate({
    inline: false,
    base: 'dist/',
    src: 'index.html',
    width: 1200,
    height: 800,
    minify: false // We'll minify separately for better control
  })

  // Minify the critical CSS
  const result = await postcss([
    cssnano({
      preset: [
        'advanced',
        {
          discardComments: { removeAll: true },
          normalizeWhitespace: true,
          colormin: true
        }
      ]
    })
  ]).process(css, { from: undefined })

  // Save minified critical CSS
  fs.writeFileSync('dist/css/critical.min.css', result.css)

  console.log('✅ Critical CSS extracted and minified')
}
```

### CSS Splitting and Minification
```javascript
// webpack.config.js - Advanced CSS splitting
module.exports = {
  optimization: {
    splitChunks: {
      cacheGroups: {
        // Critical CSS
        critical: {
          name: 'critical',
          test: /critical\.(css|scss)$/,
          chunks: 'all',
          enforce: true,
          priority: 30
        },

        // Vendor CSS
        vendorStyles: {
          name: 'vendor',
          test: /[\\/]node_modules[\\/].*\.(css|scss)$/,
          chunks: 'all',
          enforce: true,
          priority: 20
        },

        // Component CSS
        componentStyles: {
          name: 'components',
          test: /components.*\.(css|scss)$/,
          chunks: 'all',
          enforce: true,
          priority: 10
        }
      }
    },

    minimizer: [
      new CssMinimizerPlugin({
        parallel: true,
        minimizerOptions: {
          preset: [
            'advanced',
            {
              autoprefixer: false, // Disable if you're using autoprefixer separately
              discardComments: { removeAll: true },
              normalizeWhitespace: true,
              colormin: true,
              convertValues: true,
              discardDuplicates: true,
              mergeRules: true,
              minifySelectors: true,
              reduceInitial: true,
              svgo: {
                plugins: [
                  { name: 'removeViewBox', active: false },
                  { name: 'removeDimensions', active: true }
                ]
              }
            }
          ]
        }
      })
    ]
  }
}
```

## Performance Monitoring

### Measuring CSS Optimization Impact
```javascript
// Performance monitoring script
function measureCSSPerformance() {
  const observer = new PerformanceObserver((list) => {
    for (const entry of list.getEntries()) {
      if (entry.name.includes('.css')) {
        console.log('CSS File:', entry.name)
        console.log('Load Time:', entry.duration + 'ms')
        console.log('Transfer Size:', entry.transferSize + ' bytes')
        console.log('Encoded Size:', entry.encodedBodySize + ' bytes')
        console.log('Compression Ratio:',
          ((entry.transferSize / entry.encodedBodySize) * 100).toFixed(1) + '%')
      }
    }
  })

  observer.observe({ entryTypes: ['resource'] })
}

// Run after page load
window.addEventListener('load', measureCSSPerformance)
```

### Lighthouse CSS Auditing
```javascript
// lighthouse-css-audit.js
const lighthouse = require('lighthouse')
const chromeLauncher = require('chrome-launcher')

async function auditCSS(url) {
  const chrome = await chromeLauncher.launch({ chromeFlags: ['--headless'] })

  const options = {
    logLevel: 'info',
    output: 'json',
    onlyCategories: ['performance'],
    port: chrome.port
  }

  const runnerResult = await lighthouse(url, options)

  // Extract CSS-related audits
  const cssAudits = {
    'css-minification': runnerResult.lhr.audits['css-minification'],
    'unused-css-rules': runnerResult.lhr.audits['unused-css-rules'],
    'render-blocking-resources': runnerResult.lhr.audits['render-blocking-resources']
  }

  console.log('CSS Performance Audits:', cssAudits)

  await chrome.kill()
  return cssAudits
}

auditCSS('http://localhost:3000')
```

## Best Practices

1. **Automate in Build Process**: Never manually minify CSS
2. **Source Maps**: Generate source maps for debugging minified CSS
3. **Environment-Specific**: Only minify in production builds
4. **Test After Minification**: Ensure styles work correctly after minification
5. **Monitor File Sizes**: Track CSS bundle sizes over time
6. **Critical CSS**: Inline and minify critical CSS separately
7. **Cache Busting**: Use content hashes in filenames for cache invalidation
8. **Compression**: Combine minification with gzip/brotli compression
9. **Dead Code Elimination**: Remove unused CSS before minification
10. **Performance Budget**: Set and monitor CSS size budgets

## Common Issues and Solutions

### Broken Selectors After Minification
```css
/* Problem: Over-aggressive selector minification */
/* Before: */
.my-component .nested-element { }

/* After (broken): */
.a .b { }

/* Solution: Configure cssnano to preserve class names */
cssnano({
  preset: ['default', {
    discardComments: { removeAll: true },
    minifySelectors: false // Disable if breaking selectors
  }]
})
```

### Missing Vendor Prefixes
```javascript
// Solution: Use autoprefixer before minification
postcss([
  require('autoprefixer'),
  require('cssnano')
])
```

### Source Map Issues
```javascript
// webpack.config.js
module.exports = {
  devtool: process.env.NODE_ENV === 'production'
    ? 'source-map'  // Separate source map file
    : 'eval-source-map', // Inline for development
}
```

## Verification

### Automated Checks

- Confirm the computed styles match the intended fix in DevTools.
- If the rule affects motion, contrast, or layout stability, verify those user-facing outcomes directly.

### Manual Checks

- Inspect the rendered UI at the breakpoints and interaction states affected by the rule.
- Test at least one mobile and one desktop viewport before shipping.
brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).Stars: 322kUpdated Claude CodeCodexVerifiedInstall
brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
frontend-designanthropics/skillsGuidance 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.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).Stars: 198kUpdated Claude CodeCodexVerifiedInstall