bundle-size-optimization

Reduce JavaScript and CSS bundle sizes through code splitting, tree shaking, and optimization techniques. Improve load times and overall application performance.

⭐25stars🔀1forks📁View on GitHub🕐Updated Dec 28, 2025

When & Why to Use This Skill

This Claude skill empowers developers to significantly enhance web application performance by optimizing JavaScript and CSS bundle sizes. It offers actionable insights into code splitting, tree shaking, and dependency management, helping teams achieve faster load times and meet strict performance budgets through systematic analysis and implementation strategies.

Use Cases

  • Identifying and replacing heavy legacy libraries (e.g., Moment.js) with modern, tree-shakable alternatives to reduce the overall application footprint.
  • Implementing automated bundle analysis and size budgeting within CI/CD workflows to prevent performance regressions during the deployment process.
  • Optimizing initial page load times for mobile users by applying route-based code splitting and lazy loading for non-critical components.
  • Conducting deep-dive audits of existing build configurations to enable advanced tree shaking and minification techniques for cleaner production code.
namebundle-size-optimization
descriptionReduce JavaScript and CSS bundle sizes through code splitting, tree shaking, and optimization techniques. Improve load times and overall application performance.

Bundle Size Optimization

Overview

Smaller bundles download faster, parse faster, and execute faster, dramatically improving perceived performance especially on slower networks.

When to Use

  • Build process optimization
  • Bundle analysis before deployment
  • Performance baseline improvement
  • Mobile performance focus
  • After adding new dependencies

Instructions

1. Bundle Analysis

// Analyze bundle composition

class BundleAnalysis {
  analyzeBundle() {
    return {
      tools: [
        'webpack-bundle-analyzer',
        'Source Map Explorer',
        'Bundle Buddy',
        'Bundlephobia'
      ],
      metrics: {
        total_size: '850KB gzipped',
        main_js: '450KB',
        main_css: '120KB',
        vendor: '250KB',
        largest_lib: 'moment.js (67KB)'
      },
      breakdown: {
        react: '85KB (10%)',
        lodash: '45KB (5%)',
        moment: '67KB (8%)',
        other: '653KB (77%)'
      }
    };
  }

  identifyOpportunities(bundle) {
    const opportunities = [];

    // Check for duplicate dependencies
    if (bundle.duplicates.length > 0) {
      opportunities.push({
        issue: 'Duplicate dependencies',
        impact: '50KB reduction possible',
        solution: 'Deduplicate packages'
      });
    }

    // Check for unused packages
    if (bundle.unused.length > 0) {
      opportunities.push({
        issue: 'Unused dependencies',
        impact: '100KB reduction',
        solution: 'Remove unused packages'
      });
    }

    // Check bundle size vs targets
    if (bundle.gzipped > 250) {
      opportunities.push({
        issue: 'Bundle too large',
        impact: 'Exceeds target',
        solution: 'Code splitting or tree shaking'
      });
    }

    return opportunities;
  }
}

2. Optimization Techniques

Code Splitting:
  Route-based: Split by route (each route ~50-100KB)
  Component-based: Split large components
  Library splitting: Separate vendor bundles
  Tools: webpack, dynamic imports, React.lazy()

Tree Shaking:
  Remove unused exports
  Enable in webpack/rollup
  Works best with ES modules
  Check: bundle-analyzer shows unused

Minification:
  JavaScript: Terser, esbuild
  CSS: cssnano, clean-css
  Results: 20-30% reduction typical
  Examples: 100KB → 70KB

Remove Dependencies:
  Moment.js (67KB) → date-fns (13KB)
  Lodash (70KB) → lodash-es (30KB, can tree-shake)
  Old packages check: npm outdated

Dynamic Imports:
  import('module') loads on-demand
  Reduces initial bundle
  Used for: Modals, off-screen features
  Example: 850KB → 400KB initial + lazy

---

Bundle Size Targets:

JavaScript:
  Initial: <150KB gzipped
  Per route: <50KB gzipped
  Total: <300KB gzipped

CSS:
  Initial: <50KB gzipped
  Per page: <20KB gzipped

Images:
  Total: <500KB optimized
  Per image: <100KB

3. Implementation Strategy

Optimization Plan:

Week 1: Analysis & Quick Wins
  - Run bundle analyzer
  - Remove unused dependencies
  - Update large libraries
  - Enable tree shaking
  - Expected: 20% reduction

Week 2: Code Splitting
  - Implement route-based splitting
  - Lazy load heavy components
  - Split vendor bundles
  - Expected: 40% reduction from initial

Week 3: Advanced Optimization
  - Remove unused polyfills
  - Upgrade transpiler
  - Optimize images in bundle
  - Expected: 50-60% total reduction

---

Monitoring:

Setup Budget:
  - Track bundle size in CI/CD
  - Alert if exceeds threshold
  - Track per commit
  - Historical trending

Tools:
  - bundlesize npm package
  - webpack-bundle-analyzer
  - GitHub checks integration

Process:
  - Measure before
  - Implement changes
  - Measure after
  - Document findings

4. Best Practices

  • Monitor bundle size regularly (every build)
  • Set strict bundle budgets for teams
  • Use modern syntax (don't polyfill all browsers)
  • Prefer lighter alternatives to heavy libraries
  • Lazy load non-critical code
  • Keep vendors separate for better caching
  • Remove unused dependencies (npm audit)
  • Use production build for measurements
  • Test on real 3G network simulation

Checklist

  • Bundle analyzer installed and configured
  • Unused dependencies removed
  • Code splitting implemented
  • Tree shaking enabled
  • Bundle budget set in CI/CD
  • Large libraries replaced with lighter alternatives
  • Dynamic imports for large features
  • Vendor bundles separated
  • Assets optimized
  • Performance baseline established

Tips

  • Focus on initial bundle first (affects load time most)
  • Measure gzipped size (what users receive)
  • Tree shaking works best with ES modules only
  • Most libraries have lighter alternatives
  • Use webpack/vite analyze tools built-in