Generated banner for Progressive Blur
Generated logo for Progressive Blur

Progressive Blur

Meng ToCommunityCreated by Meng To

  • Skill
  • Tool integration
  • Software development
  • MIT
  • Medium risk

From the author

Create a layered CSS progressive blur (top or bottom) using multiple backdrop-filter masks for depth and softness. Use when asked for “progressive blur”, “gradient blur overlay”, or stepped blur masks that fade from an edge of the viewport.
— the description by Meng To

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to creating gradient blur overlays in CSS. By layering multiple elements with varying backdrop-filter intensities and mask gradients, it achieves a smooth, professional fade effect at the edges of a viewport. The implementation is designed to be flexible, allowing developers to easily adjust the direction, height, and intensity of the blur to suit specific UI requirements.

What it does

  • Generates CSS code for top or bottom-aligned progressive blur overlays.
  • Uses layered backdrop-filter properties to create a smooth transition.
  • Provides a modular HTML structure for easy integration into existing projects.
  • Offers customization knobs for blur strength, height, and gradient direction.
  • Includes a usage checklist to ensure correct DOM placement and z-index management.

When to use it

  • When you need a gradient blur overlay that fades content at the edge of the screen.
  • When implementing UI components that require depth and softness.
  • When you need to ensure content remains readable behind a blurred overlay.
  • When you want a performant, CSS-only solution for progressive blurring.

Advantages

  • Pure CSS implementation avoids heavy JavaScript dependencies.
  • Highly customizable via simple CSS property adjustments.
  • Layered approach creates a more natural, smooth blur effect than single-filter methods.
  • Includes built-in performance considerations for low-end devices.

Usage examples

“Create a progressive blur at the top of my page.”
The agent will provide the HTML and CSS snippet configured for a top-aligned gradient blur, along with instructions on where to place it in the DOM.
“How can I make my bottom blur effect taller?”
The agent will explain how to adjust the height percentage on the .gradient-blur class to increase the vertical span of the blur.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/mengto/progressive-blur/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip progressive-blur.zip -d .agents/skills

Documentation by Meng To

Progressive Blur Skill

Workflow

  1. Confirm placement (top or bottom), height, and z-index relative to UI.

  2. Provide the matching snippet and a short usage checklist.

  3. Offer only targeted tweaks (height, blur steps, direction, opacity stops).

Usage checklist

  • Insert the HTML inside <body>.

  • Keep the .gradient-blur element near the top of the DOM.

  • Ensure the background behind it exists (backdrop-filter blurs what is behind).

  • Adjust z-index to sit above content but below modals.

Top blur (from top)

<div class="gradient-blur">
  <div></div><div></div><div></div><div></div><div></div><div></div>
</div>
<style>
  .gradient-blur {
    position: fixed;
    z-index: 5;
    inset: 0 0 auto 0;
    height: 12%;
    pointer-events: none;
  }

  .gradient-blur > div,
  .gradient-blur::before,
  .gradient-blur::after {
    position: absolute;
    inset: 0;
  }

  .gradient-blur::before {
    content: "";
    z-index: 1;
    backdrop-filter: blur(0.5px);
    mask: linear-gradient(to top,
      rgba(0, 0, 0, 0) 0%,
      rgba(0, 0, 0, 1) 12.5%,
      rgba(0, 0, 0, 1) 25%,
      rgba(0, 0, 0, 0) 37.5%);
  }

  .gradient-blur > div:nth-of-type(1) {
    z-index: 2;
    backdrop-filter: blur(1px);
    mask: linear-gradient(to top,
      rgba(0, 0, 0, 0) 12.5%,
      rgba(0, 0, 0, 1) 25%,
      rgba(0, 0, 0, 1) 37.5%,
      rgba(0, 0, 0, 0) 50%);
  }

  .gradient-blur > div:nth-of-type(2) {
    z-index: 3;
    backdrop-filter: blur(2px);
    mask: linear-gradient(to top,
      rgba(0, 0, 0, 0) 25%,
      rgba(0, 0, 0, 1) 37.5%,
      rgba(0, 0, 0, 1) 50%,
      rgba(0, 0, 0, 0) 62.5%);
  }

  .gradient-blur > div:nth-of-type(3) {
    z-index: 4;
    backdrop-filter: blur(4px);
    mask: linear-gradient(to top,
      rgba(0, 0, 0, 0) 37.5%,
      rgba(0, 0, 0, 1) 50%,
      rgba(0, 0, 0, 1) 62.5%,
      rgba(0, 0, 0, 0) 75%);
  }

  .gradient-blur > div:nth-of-type(4) {
    z-index: 5;
    backdrop-filter: blur(8px);
    mask: linear-gradient(to top,
      rgba(0, 0, 0, 0) 50%,
      rgba(0, 0, 0, 1) 62.5%,
      rgba(0, 0, 0, 1) 75%,
      rgba(0, 0, 0, 0) 87.5%);
  }

  .gradient-blur > div:nth-of-type(5) {
    z-index: 6;
    backdrop-filter: blur(16px);
    mask: linear-gradient(to top,
      rgba(0, 0, 0, 0) 62.5%,
      rgba(0, 0, 0, 1) 75%,
      rgba(0, 0, 0, 1) 87.5%,
      rgba(0, 0, 0, 0) 100%);
  }

  .gradient-blur > div:nth-of-type(6) {
    z-index: 7;
    backdrop-filter: blur(32px);
    mask: linear-gradient(to top,
      rgba(0, 0, 0, 0) 75%,
      rgba(0, 0, 0, 1) 87.5%,
      rgba(0, 0, 0, 1) 100%);
  }

  .gradient-blur::after {
    content: "";
    z-index: 8;
    backdrop-filter: blur(64px);
    mask: linear-gradient(to top,
      rgba(0, 0, 0, 0) 87.5%,
      rgba(0, 0, 0, 1) 100%);
  }
</style>

Bottom blur (from bottom)

<div class="gradient-blur">
  <div></div><div></div><div></div><div></div><div></div><div></div>
</div>
<style>
  .gradient-blur {
    position: fixed;
    z-index: 5;
    inset: auto 0 0 0;
    height: 65%;
    pointer-events: none;
  }

  .gradient-blur > div,
  .gradient-blur::before,
  .gradient-blur::after {
    position: absolute;
    inset: 0;
  }

  .gradient-blur::before {
    content: "";
    z-index: 1;
    backdrop-filter: blur(0.5px);
    mask: linear-gradient(to bottom,
      rgba(0, 0, 0, 0) 0%,
      rgba(0, 0, 0, 1) 12.5%,
      rgba(0, 0, 0, 1) 25%,
      rgba(0, 0, 0, 0) 37.5%);
  }

  .gradient-blur > div:nth-of-type(1) {
    z-index: 2;
    backdrop-filter: blur(1px);
    mask: linear-gradient(to bottom,
      rgba(0, 0, 0, 0) 12.5%,
      rgba(0, 0, 0, 1) 25%,
      rgba(0, 0, 0, 1) 37.5%,
      rgba(0, 0, 0, 0) 50%);
  }

  .gradient-blur > div:nth-of-type(2) {
    z-index: 3;
    backdrop-filter: blur(2px);
    mask: linear-gradient(to bottom,
      rgba(0, 0, 0, 0) 25%,
      rgba(0, 0, 0, 1) 37.5%,
      rgba(0, 0, 0, 1) 50%,
      rgba(0, 0, 0, 0) 62.5%);
  }

  .gradient-blur > div:nth-of-type(3) {
    z-index: 4;
    backdrop-filter: blur(4px);
    mask: linear-gradient(to bottom,
      rgba(0, 0, 0, 0) 37.5%,
      rgba(0, 0, 0, 1) 50%,
      rgba(0, 0, 0, 1) 62.5%,
      rgba(0, 0, 0, 0) 75%);
  }

  .gradient-blur > div:nth-of-type(4) {
    z-index: 5;
    backdrop-filter: blur(8px);
    mask: linear-gradient(to bottom,
      rgba(0, 0, 0, 0) 50%,
      rgba(0, 0, 0, 1) 62.5%,
      rgba(0, 0, 0, 1) 75%,
      rgba(0, 0, 0, 0) 87.5%);
  }

  .gradient-blur > div:nth-of-type(5) {
    z-index: 6;
    backdrop-filter: blur(16px);
    mask: linear-gradient(to bottom,
      rgba(0, 0, 0, 0) 62.5%,
      rgba(0, 0, 0, 1) 75%,
      rgba(0, 0, 0, 1) 87.5%,
      rgba(0, 0, 0, 0) 100%);
  }

  .gradient-blur > div:nth-of-type(6) {
    z-index: 7;
    backdrop-filter: blur(32px);
    mask: linear-gradient(to bottom,
      rgba(0, 0, 0, 0) 75%,
      rgba(0, 0, 0, 1) 87.5%,
      rgba(0, 0, 0, 1) 100%);
  }

  .gradient-blur::after {
    content: "";
    z-index: 8;
    backdrop-filter: blur(64px);
    mask: linear-gradient(to bottom,
      rgba(0, 0, 0, 0) 87.5%,
      rgba(0, 0, 0, 1) 100%);
  }
</style>

Customization knobs

  • Direction: flip to top ↔ to bottom.

  • Height: adjust .gradient-blur height percentage.

  • Strength: change blur values (0.5px → 64px).

  • Steps: add/remove layers to control smoothness.

Common pitfalls

  • backdrop-filter needs content behind it; it will not blur a flat background.

  • High blur values are GPU-heavy; reduce steps on low-end devices.

  • Ensure pointer-events: none stays to avoid blocking clicks.

Questions to ask when specs are missing

  • Should the blur start from the top or bottom?

  • How tall should the blur area be?

  • Is performance a concern on lower-end devices?

Files

demo/index.html

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta name="neuform-sandboxed-demo" content="1">
  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; connect-src 'self'; frame-src 'self'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'; object-src 'none'">
  <title>Sandboxed Neuform demo</title>
  <style>
    html, body, iframe { width: 100%; height: 100%; margin: 0; border: 0; }
    body { overflow: hidden; background: #0b0b0b; }
    iframe { display: block; background: white; }
    .error { box-sizing: border-box; min-height: 100%; padding: 32px; color: #fff; font: 16px/1.5 system-ui, sans-serif; }
  </style>
</head>
<body>
  <iframe id="neuform-demo" title="Sandboxed Neuform design demo" sandbox="allow-scripts" referrerpolicy="no-referrer"></iframe>
  <script>
    const encodedHtml = "<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="Content-Security-Policy" content="default-src 'none'; base-uri 'none'; connect-src 'none'; font-src data: https://fonts.gstatic.com; form-action 'none'; frame-src 'none'; img-src blob:; media-src blob:; navigate-to 'none'; object-src 'none'; script-src 'unsafe-inline' __NEUFORM_RUNTIME_SOURCES__; style-src 'unsafe-inline' https://api.fontshare.com https://fonts.googleapis.com; worker-src 'none'">
<script data-neuform-asset-bootstrap>
(() => {
  let received = false;
  const objectUrls = [];
  const replaceAll = (value, replacements) => {
    let next = String(value || "");
    for (const [file, objectUrl] of replacements) next = next.split(file).join(objectUrl);
    return next;
  };
  window.addEventListener("message", (event) => {
    if (received || event.source !== parent || event.data?.type !== "neuform-assets-v1") return;
    received = true;
    const replacements = [];
    for (const asset of event.data.assets || []) {
      if (!asset || typeof asset.file !== "string" || typeof asset.base64 !== "string") continue;
      const binary = atob(asset.base64);
      const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
      const objectUrl = URL.createObjectURL(new Blob([bytes], { type: asset.contentType || "application/octet-stream" }));
      objectUrls.push(objectUrl);
      replacements.push([asset.file, objectUrl]);
    }
    for (const element of document.querySelectorAll("*")) {
      for (const name of ["src", "poster", "srcset", "style"]) {
        const value = element.getAttribute(name);
        if (value) element.setAttribute(name, replaceAll(value, replacements));
      }
    }
    for (const style of document.querySelectorAll("style")) {
      style.textContent = replaceAll(style.textContent, replacements);
    }
  });
  window.addEventListener("pagehide", () => {
    for (const objectUrl of objectUrls) URL.revokeObjectURL(objectUrl);
  }, { once: true });
})();
</script>

<meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>GOLABS | Performance Hydration Collection</title>
    
    <!-- Tailwind CSS -->
    <script src="../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"></script>
    
    <!-- Iconify -->
    <script src="../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js"></script>
    
    <!-- GSAP -->
    <script src="../../../../assets/runtime/runtime-027051effa47-gsap-min.js"></script>
    <script src="../../../../assets/runtime/runtime-689ca8dda44c-scrolltrigger-min.js"></script>

    <style>
        @import url('https://fonts.googleapis.com/css2?family=Bebas+Neue&family=Inter:wght@400;500;600&display=swap');
        
        body {
            font-family: 'Inter', sans-serif;
        }

        /* Progressive Blur - Bottom Fade */
        .gradient-blur {
            position: fixed;
            z-index: 40;
            inset: auto 0 0 0;
            height: 10vh;
            pointer-events: none;
        }
        .gradient-blur > div,
        .gradient-blur::before,
        .gradient-blur::after {
            position: absolute;
            inset: 0;
        }
        .gradient-blur::before {
            content: "";
            z-index: 1;
            backdrop-filter: blur(0.5px);
            mask: linear-gradient(to bottom, rgba(0, 0, 0, 0) 0%, rgba(0, 0, 0, 1) 12.5%, rgba(0, 0, 0, 1) 25%, rgba(0, 0, 0, 0) 37.5%);
        }
        .gradient-blur > div:nth-of-type(1) {
            z-index: 2;
            backdrop-filter: blur(1px);
            mask: linear-gradient(to bottom, rgba(0, 0, 0, 0) 12.5%, rgba(0, 0, 0, 1) 25%, rgba(0, 0, 0, 1) 37.5%, rgba(0, 0, 0, 0) 50%);
        }
        .gradient-blur > div:nth-of-type(2) {
            z-index: 3;
            backdrop-filter: blur(2px);
            mask: linear-gradient(to bottom, rgba(0, 0, 0, 0) 25%, rgba(0, 0, 0, 1) 37.5%, rgba(0, 0, 0, 1) 50%, rgba(0, 0, 0, 0) 62.5%);
        }
        .gradient-blur > div:nth-of-type(3) {
            z-index: 4;
            backdrop-filter: blur(4px);
            mask: linear-gradient(to bottom, rgba(0, 0, 0, 0) 37.5%, rgba(0, 0, 0, 1) 50%, rgba(0, 0, 0, 1) 62.5%, rgba(0, 0, 0, 0) 75%);
        }
        .gradient-blur > div:nth-of-type(4) {
            z-index: 5;
            backdrop-filter: blur(8px);
            mask: linear-gradient(to bottom, rgba(0, 0, 0, 0) 50%, rgba(0, 0, 0, 1) 62.5%, rgba(0, 0, 0, 1) 75%, rgba(0, 0, 0, 0) 87.5%);
        }
        .gradient-blur > div:nth-of-type(5) {
            z-index: 6;
            backdrop-filter: blur(16px);
            mask: linear-gradient(to bottom, rgba(0, 0, 0, 0) 62.5%, rgba(0, 0, 0, 1) 75%, rgba(0, 0, 0, 1) 87.5%, rgba(0, 0, 0, 0) 100%);
        }
        .gradient-blur > div:nth-of-type(6) {
            z-index: 7;
            backdrop-filter: blur(32px);
            mask: linear-gradient(to bottom, rgba(0, 0, 0, 0) 75%, rgba(0, 0, 0, 1) 87.5%, rgba(0, 0, 0, 1) 100%);
        }
        .gradient-blur::after {
            content: "";
            z-index: 8;
            backdrop-filter: blur(64px);
            mask: linear-gradient(to bottom, rgba(0, 0, 0, 0) 87.5%, rgba(0, 0, 0, 1) 100%);
        }

        /* Hide Scrollbar for Horizontal Scrollers */
        .no-scrollbar::-webkit-scrollbar {
            display: none;
        }
        .no-scrollbar {
            -ms-overflow-style: none;
            scrollbar-width: none;
        }
    </style>
</head>
<body class="antialiased selection:bg-black selection:text-white pb-24 bg-[#FAFAF7] text-black">

    <!-- Progressive Bottom Blur -->
    <div class="gradient-blur">
        <div></div><div></div><div></div><div></div><div></div><div></div>
    </div>

    <!-- Announcement Bar -->
    <div class="bg-black text-white text-[11px] font-semibold text-center py-2.5 uppercase tracking-widest">
        Free Shipping over €50 &nbsp;|&nbsp; Subscribe & Save &nbsp;|&nbsp; Backed by Science
    </div>

    <!-- Navbar -->
    <header class="flex items-center justify-between px-6 lg:px-10 py-5 border-b border-black/5 bg-[#FAFAF7] sticky top-0 z-50">
        <!-- Left Nav -->
        <nav class="hidden lg:flex space-x-8 text-xs font-semibold uppercase tracking-wide">
            <a href="#" class="hover:text-gray-500 transition-colors">Shop</a>
            <a href="#" class="hover:text-gray-500 transition-colors">Science</a>
            <a href="#" class="hover:text-gray-500 transition-colors">Fuel Club</a>
            <a href="#" class="hover:text-gray-500 transition-colors">Stores</a>
            <a href="#" class="hover:text-gray-500 transition-colors">Subscription</a>
        </nav>
        
        <!-- Mobile Menu Icon -->
        <div class="lg:hidden flex items-center">
            <iconify-icon icon="solar:hamburger-menu-linear" width="28" stroke-width="1.5" class="cursor-pointer"></iconify-icon>
        </div>

        <!-- Center Logo -->
        <div class="text-3xl font-bold tracking-tighter uppercase absolute left-1/2 -translate-x-1/2">
            GOLABS
        </div>

        <!-- Right Icons -->
        <div class="flex items-center space-x-6">
            <span class="text-xs font-semibold uppercase hidden sm:block hover:text-gray-500 cursor-pointer transition-colors">EN/€</span>
            <iconify-icon icon="solar:user-linear" width="24" stroke-width="1.5" class="cursor-pointer hover:text-gray-500 transition-colors"></iconify-icon>
            <iconify-icon icon="solar:magnifer-linear" width="24" stroke-width="1.5" class="cursor-pointer hover:text-gray-500 transition-colors"></iconify-icon>
            <iconify-icon icon="solar:cart-large-minimalistic-linear" width="24" stroke-width="1.5" class="cursor-pointer hover:text-gray-500 transition-colors"></iconify-icon>
        </div>
    </header>

    <!-- Page Title / Masked Reveal Section -->
    <div class="px-6 py-16 md:py-24 flex flex-col items-center justify-center text-center overflow-hidden">
        <h1 class="font-['Bebas_Neue'] text-7xl md:text-9xl tracking-tight uppercase leading-[0.85] flex flex-col items-center">
            <span class="block overflow-hidden pb-1"><span class="block gs-reveal-word translate-y-full">Complete</span></span>
            <span class="block overflow-hidden pb-1"><span class="block gs-reveal-word translate-y-full">Hydration System</span></span>
        </h1>
        <p class="mt-6 text-sm md:text-base font-medium text-gray-500 max-w-md mx-auto tracking-wide gs-reveal-fade opacity-0 translate-y-4">
            Engineered for performance, recovery, and daily energy.
        </p>
    </div>

    <!-- Category Tabs Segmented Nav -->
    <div class="flex items-center justify-center pb-8 px-6">
        <div class="inline-flex items-center gap-1 bg-black/5 p-1 rounded-full overflow-x-auto max-w-full no-scrollbar">
            <button class="bg-black text-white px-6 py-2.5 rounded-full text-xs font-semibold uppercase tracking-wide shrink-0 shadow-sm">Sachets</button>
            <button class="text-black hover:bg-black/10 px-6 py-2.5 rounded-full text-xs font-semibold uppercase tracking-wide shrink-0 transition-colors">Cans</button>
            <button class="text-black hover:bg-black/10 px-6 py-2.5 rounded-full text-xs font-semibold uppercase tracking-wide shrink-0 transition-colors">Bundles</button>
            <button class="text-black hover:bg-black/10 px-6 py-2.5 rounded-full text-xs font-semibold uppercase tracking-wide shrink-0 transition-colors">Gels</button>
            <button class="text-black hover:bg-black/10 px-6 py-2.5 rounded-full text-xs font-semibold uppercase tracking-wide shrink-0 transition-colors">Fuel</button>
        </div>
    </div>

    <!-- Collection Toolbar -->
    <div class="border-b border-black/10 bg-[#FAFAF7]">
        <div class="flex items-center justify-between px-6 lg:px-10 h-[64px] max-w-[1920px] mx-auto">
            <button class="flex items-center gap-2 text-xs font-semibold uppercase tracking-wide hover:opacity-60 transition-opacity">
                <iconify-icon icon="solar:filter-linear" width="18" stroke-width="1.5"></iconify-icon> Filters
            </button>
            <button class="flex items-center gap-2 text-xs font-semibold uppercase tracking-wide hover:opacity-60 transition-opacity">
                Sort By <iconify-icon icon="solar:alt-arrow-down-linear" width="18" stroke-width="1.5"></iconify-icon>
            </button>
        </div>
    </div>

    <!-- Product Grid -->
    <main class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-6 lg:gap-8 px-6 lg:px-10 py-12 w-full max-w-[1920px] mx-auto">
        
        <!-- Product 1 -->
        <article class="group relative flex flex-col bg-white rounded-[20px] p-2">
            <!-- Image Area -->
            <div class="relative w-full aspect-[4/5] bg-[#F4F4F0] rounded-[14px] overflow-hidden">
                <!-- Badges -->
                <div class="absolute top-3 left-3 flex flex-col gap-1.5 z-20">
                    <span class="bg-black text-white text-xs px-2.5 py-1 font-semibold tracking-wider uppercase rounded-sm leading-none">Subscribe</span>
                    <span class="bg-black text-white text-xs px-2.5 py-1 font-semibold tracking-wider uppercase rounded-sm leading-none">Bestseller</span>
                </div>
                <!-- Pack Size -->
                <div class="absolute top-3 right-3 flex flex-col items-center leading-none z-20 text-black">
                    <span class="text-sm font-semibold">30</span>
                    <span class="text-xs uppercase tracking-widest mt-0.5 scale-75 origin-top">Pack</span>
                </div>
                <!-- Hover Images -->
                <div class="absolute inset-0 transition-transform duration-700 ease-[cubic-bezier(0.25,1,0.5,1)] group-hover:scale-[1.04]">
                    <img src="assets/page-01-724142aa-44a6-48d3-9cf3-761e00d05b78-1600w.jpg" class="absolute inset-0 w-full h-full object-contain p-6 transition-opacity duration-500 opacity-100 group-hover:opacity-0" alt="Daily Hydration Sachets">
                    <img src="assets/page-02-0d868fef-f560-45ca-ab35-5dad4fc29059-3840w.webp" class="absolute inset-0 w-full h-full object-cover transition-opacity duration-500 opacity-0 group-hover:opacity-100" alt="Daily Hydration Sachets Lifestyle">
                </div>
            </div>
            <!-- Details Area -->
            <div class="flex flex-col flex-grow pt-5 pb-3 px-3">
                <h2 class="text-base font-semibold tracking-tight text-black mb-1">Daily Hydration Sachets - Citrus</h2>
                <p class="text-sm font-normal text-gray-500 line-clamp-2 mb-5 leading-relaxed">Core hydration electrolyte sachets designed to support daily hydration, energy and mineral balance.</p>
                
                <button class="mt-auto w-full h-[44px] rounded-full border border-black bg-white text-black text-xs font-semibold uppercase tracking-wider flex items-center justify-center transition-all duration-300 group-hover:bg-black group-hover:text-white transform group-hover:scale-[1.01]">
                    Add to Cart &mdash; €34.99
                </button>
            </div>
        </article>

        <!-- Product 2 -->
        <article class="group relative flex flex-col bg-white rounded-[20px] p-2">
            <div class="relative w-full aspect-[4/5] bg-[#F4F4F0] rounded-[14px] overflow-hidden">
                <div class="absolute top-3 left-3 flex flex-col gap-1.5 z-20">
                    <span class="bg-black text-white text-xs px-2.5 py-1 font-semibold tracking-wider uppercase rounded-sm leading-none">Bestseller</span>
                    <span class="bg-black text-white text-xs px-2.5 py-1 font-semibold tracking-wider uppercase rounded-sm leading-none">Subscribe</span>
                </div>
                <div class="absolute inset-0 transition-transform duration-700 ease-[cubic-bezier(0.25,1,0.5,1)] group-hover:scale-[1.04]">
                    <img src="assets/page-03-005600e5-f6ab-4e59-bc86-eaeb02797dfa-1600w.jpg" class="absolute inset-0 w-full h-full object-contain p-6 transition-opacity duration-500 opacity-100 group-hover:opacity-0" alt="Starter Hydration System">
                    <img src="assets/page-04-3186f9ea-5f5a-49f7-8fcf-568ad52f515e-3840w.webp" class="absolute inset-0 w-full h-full object-cover transition-opacity duration-500 opacity-0 group-hover:opacity-100" alt="Starter Hydration System Lifestyle">
                </div>
            </div>
            <div class="flex flex-col flex-grow pt-5 pb-3 px-3">
                <h2 class="text-base font-semibold tracking-tight text-black mb-1">Starter Hydration System</h2>
                <p class="text-sm font-normal text-gray-500 line-clamp-2 mb-5 leading-relaxed">The complete introduction to the GOLABS hydration system with sachets, cans, and a training bottle.</p>
                
                <button class="mt-auto w-full h-[44px] rounded-full border border-black bg-white text-black text-xs font-semibold uppercase tracking-wider flex items-center justify-center transition-all duration-300 group-hover:bg-black group-hover:text-white transform group-hover:scale-[1.01]">
                    Add to Cart &mdash; €65.00
                </button>
            </div>
        </article>

        <!-- Product 3 -->
        <article class="group relative flex flex-col bg-white rounded-[20px] p-2">
            <div class="relative w-full aspect-[4/5] bg-[#F4F4F0] rounded-[14px] overflow-hidden">
                <div class="absolute top-3 left-3 flex flex-col gap-1.5 z-20">
                    <span class="bg-black text-white text-xs px-2.5 py-1 font-semibold tracking-wider uppercase rounded-sm leading-none">Bestseller</span>
                </div>
                <div class="absolute inset-0 transition-transform duration-700 ease-[cubic-bezier(0.25,1,0.5,1)] group-hover:scale-[1.04]">
                    <img src="assets/page-05-7f78131e-65e9-49b2-aa1f-ccc33e28df9f-1600w.webp" class="absolute inset-0 w-full h-full object-contain p-6 transition-opacity duration-500 opacity-100 group-hover:opacity-0" alt="Sleep Hydration Sachets">
                    <img src="assets/page-06-4f5668c5-fc4a-44e0-bc5e-a664189d3c31-1600w.jpg" class="absolute inset-0 w-full h-full object-cover transition-opacity duration-500 opacity-0 group-hover:opacity-100" alt="Sleep Hydration Sachets Lifestyle">
                </div>
            </div>
            <div class="flex flex-col flex-grow pt-5 pb-3 px-3">
                <h2 class="text-base font-semibold tracking-tight text-black mb-1">Sleep Hydration Sachets</h2>
                <p class="text-sm font-normal text-gray-500 line-clamp-2 mb-5 leading-relaxed">Overnight electrolyte blend with sleep-supporting ingredients designed for recovery and restoration.</p>
                
                <button class="mt-auto w-full h-[44px] rounded-full border border-black bg-white text-black text-xs font-semibold uppercase tracking-wider flex items-center justify-center transition-all duration-300 group-hover:bg-black group-hover:text-white transform group-hover:scale-[1.01]">
                    Add to Cart &mdash; €34.99
                </button>
            </div>
        </article>

        <!-- Product 4 -->
        <article class="group relative flex flex-col bg-white rounded-[20px] p-2">
            <div class="relative w-full aspect-[4/5] bg-[#F4F4F0] rounded-[14px] overflow-hidden">
                <div class="absolute top-3 left-3 flex flex-col gap-1.5 z-20">
                    <span class="bg-black text-white text-xs px-2.5 py-1 font-semibold tracking-wider uppercase rounded-sm leading-none">Bestseller</span>
                    <span class="bg-black text-white text-xs px-2.5 py-1 font-semibold tracking-wider uppercase rounded-sm leading-none">Subscribe</span>
                </div>
                <div class="absolute top-3 right-3 flex flex-col items-center leading-none z-20 text-black">
                    <span class="text-sm font-semibold">12</span>
                    <span class="text-xs uppercase tracking-widest mt-0.5 scale-75 origin-top">Pack</span>
                </div>
                <div class="absolute inset-0 transition-transform duration-700 ease-[cubic-bezier(0.25,1,0.5,1)] group-hover:scale-[1.04]">
                    <img src="assets/page-07-d14dc069-558a-4c51-8aad-5cc237f9b61d-1600w.jpg" class="absolute inset-0 w-full h-full object-contain p-6 transition-opacity duration-500 opacity-100 group-hover:opacity-0" alt="Core Hydration Drink">
                    <img src="assets/page-08-eca707cc-a5b7-439a-b4fd-247f6106c2e1-1600w.jpg" class="absolute inset-0 w-full h-full object-cover transition-opacity duration-500 opacity-0 group-hover:opacity-100" alt="Core Hydration Drink Lifestyle">
                </div>
            </div>
            <div class="flex flex-col flex-grow pt-5 pb-3 px-3">
                <h2 class="text-base font-semibold tracking-tight text-black mb-1">Core Hydration Drink - Citrus</h2>
                <p class="text-sm font-normal text-gray-500 line-clamp-2 mb-5 leading-relaxed">Ready-to-drink citrus electrolytes with sodium, potassium and magnesium for daily performance.</p>
                
                <button class="mt-auto w-full h-[44px] rounded-full border border-black bg-white text-black text-xs font-semibold uppercase tracking-wider flex items-center justify-center transition-all duration-300 group-hover:bg-black group-hover:text-white transform group-hover:scale-[1.01]">
                    Add to Cart &mdash; €24.00
                </button>
            </div>
        </article>

        <!-- Product 5 -->
        <article class="group relative flex flex-col bg-white rounded-[20px] p-2">
            <div class="relative w-full aspect-[4/5] bg-[#F4F4F0] rounded-[14px] overflow-hidden">
                <div class="absolute top-3 left-3 flex flex-col gap-1.5 z-20">
                    <span class="bg-black text-white text-xs px-2.5 py-1 font-semibold tracking-wider uppercase rounded-sm leading-none">Subscribe</span>
                </div>
                <div class="absolute top-3 right-3 flex flex-col items-center leading-none z-20 text-black">
                    <span class="text-sm font-semibold">12</span>
                    <span class="text-xs uppercase tracking-widest mt-0.5 scale-75 origin-top">Pack</span>
                </div>
                <div class="absolute inset-0 transition-transform duration-700 ease-[cubic-bezier(0.25,1,0.5,1)] group-hover:scale-[1.04]">
                    <img src="assets/page-09-4734259a-bad7-422f-981e-ce01e79184f2-1600w.jpg" class="absolute inset-0 w-full h-full object-contain p-6 transition-opacity duration-500 opacity-100 group-hover:opacity-0" alt="Core Hydration Drink Berry">
                    <img src="assets/page-10-77415a2e-dcbc-4748-a29d-fced4821881a-1600w.jpg" class="absolute inset-0 w-full h-full object-cover transition-opacity duration-500 opacity-0 group-hover:opacity-100" alt="Core Hydration Drink Berry Lifestyle">
                </div>
            </div>
            <div class="flex flex-col flex-grow pt-5 pb-3 px-3">
                <h2 class="text-base font-semibold tracking-tight text-black mb-1">Core Hydration Drink - Berry</h2>
                <p class="text-sm font-normal text-gray-500 line-clamp-2 mb-5 leading-relaxed">Ready-to-drink berry electrolytes for hydration, training and everyday energy.</p>
                
                <button class="mt-auto w-full h-[44px] rounded-full border border-black bg-white text-black text-xs font-semibold uppercase tracking-wider flex items-center justify-center transition-all duration-300 group-hover:bg-black group-hover:text-white transform group-hover:scale-[1.01]">
                    Add to Cart &mdash; €24.00
                </button>
            </div>
        </article>

        <!-- Product 6 -->
        <article class="group relative flex flex-col bg-white rounded-[20px] p-2">
            <div class="relative w-full aspect-[4/5] bg-[#F4F4F0] rounded-[14px] overflow-hidden">
                <div class="absolute top-3 left-3 flex flex-col gap-1.5 z-20">
                    <span class="bg-black text-white text-xs px-2.5 py-1 font-semibold tracking-wider uppercase rounded-sm leading-none">Bestseller</span>
                </div>
                <div class="absolute inset-0 transition-transform duration-700 ease-[cubic-bezier(0.25,1,0.5,1)] group-hover:scale-[1.04]">
                    <img src="assets/page-11-5ee0a38a-b5d3-4531-8793-98beed4af162-1600w.jpg" class="absolute inset-0 w-full h-full object-contain p-6 transition-opacity duration-500 opacity-100 group-hover:opacity-0" alt="Electrolyte Bundle">
                    <img src="assets/page-12-65695f80-23f9-46ee-8487-cbb6c93cc48b-3840w.webp" class="absolute inset-0 w-full h-full object-cover transition-opacity duration-500 opacity-0 group-hover:opacity-100" alt="Electrolyte Bundle Lifestyle">
                </div>
            </div>
            <div class="flex flex-col flex-grow pt-5 pb-3 px-3">
                <h2 class="text-base font-semibold tracking-tight text-black mb-1">Electrolyte Bundle</h2>
                <p class="text-sm font-normal text-gray-500 line-clamp-2 mb-5 leading-relaxed">A curated performance hydration bundle made for training, recovery and daily energy.</p>
                
                <button class="mt-auto w-full h-[44px] rounded-full border border-black bg-white text-black text-xs font-semibold uppercase tracking-wider flex items-center justify-center transition-all duration-300 group-hover:bg-black group-hover:text-white transform group-hover:scale-[1.01]">
                    Add to Cart &mdash; €49.99
                </button>
            </div>
        </article>

        <!-- Product 7 -->
        <article class="group relative flex flex-col bg-white rounded-[20px] p-2">
            <div class="relative w-full aspect-[4/5] bg-[#F4F4F0] rounded-[14px] overflow-hidden">
                <div class="absolute top-3 left-3 flex flex-col gap-1.5 z-20">
                    <span class="bg-black text-white text-xs px-2.5 py-1 font-semibold tracking-wider uppercase rounded-sm leading-none">New</span>
                </div>
                <div class="absolute inset-0 transition-transform duration-700 ease-[cubic-bezier(0.25,1,0.5,1)] group-hover:scale-[1.04]">
                    <img src="assets/page-13-fb6415fd-bf4d-4ccf-8e9d-7ab445e99207-1600w.jpg" class="absolute inset-0 w-full h-full object-contain p-6 transition-opacity duration-500 opacity-100 group-hover:opacity-0" alt="Fuel Bar">
                    <img src="assets/page-14-c92852bb-a510-405a-85ab-ffa0fde136a4-1600w.jpg" class="absolute inset-0 w-full h-full object-cover transition-opacity duration-500 opacity-0 group-hover:opacity-100" alt="Fuel Bar Lifestyle">
                </div>
            </div>
            <div class="flex flex-col flex-grow pt-5 pb-3 px-3">
                <h2 class="text-base font-semibold tracking-tight text-black mb-1">Fuel Bar</h2>
                <p class="text-sm font-normal text-gray-500 line-clamp-2 mb-5 leading-relaxed">Functional performance fuel bar for athletes, creators and high-output days.</p>
                
                <button class="mt-auto w-full h-[44px] rounded-full border border-black bg-white text-black text-xs font-semibold uppercase tracking-wider flex items-center justify-center transition-all duration-300 group-hover:bg-black group-hover:text-white transform group-hover:scale-[1.01]">
                    Add to Cart &mdash; €19.99
                </button>
            </div>
        </article>

        <!-- Product 8 -->
        <article class="group relative flex flex-col bg-white rounded-[20px] p-2">
            <div class="relative w-full aspect-[4/5] bg-[#F4F4F0] rounded-[14px] overflow-hidden">
                <div class="absolute top-3 left-3 flex flex-col gap-1.5 z-20">
                    <span class="bg-black text-white text-xs px-2.5 py-1 font-semibold tracking-wider uppercase rounded-sm leading-none">New</span>
                </div>
                <div class="absolute inset-0 transition-transform duration-700 ease-[cubic-bezier(0.25,1,0.5,1)] group-hover:scale-[1.04]">
                    <img src="assets/page-15-e534354d-c5f2-4399-a1d9-2f50338e8c47-1600w.jpg" class="absolute inset-0 w-full h-full object-contain p-6 transition-opacity duration-500 opacity-100 group-hover:opacity-0" alt="Base Gel">
                    <img src="assets/page-16-2f563338-39fa-47ea-9761-658d4f3f84db-1600w.jpg" class="absolute inset-0 w-full h-full object-cover transition-opacity duration-500 opacity-0 group-hover:opacity-100" alt="Base Gel Lifestyle">
                </div>
            </div>
            <div class="flex flex-col flex-grow pt-5 pb-3 px-3">
                <h2 class="text-base font-semibold tracking-tight text-black mb-1">Base Gel</h2>
                <p class="text-sm font-normal text-gray-500 line-clamp-2 mb-5 leading-relaxed">Clean energy gel made for movement, endurance and training sessions.</p>
                
                <button class="mt-auto w-full h-[44px] rounded-full border border-black bg-white text-black text-xs font-semibold uppercase tracking-wider flex items-center justify-center transition-all duration-300 group-hover:bg-black group-hover:text-white transform group-hover:scale-[1.01]">
                    Add to Cart &mdash; €21.99
                </button>
            </div>
        </article>

    </main>

    <!-- Init GSAP Animations -->
    <script>
        document.addEventListener("DOMContentLoaded", (event) => {
            gsap.registerPlugin(ScrollTrigger);
            
            // Masked word reveal for the header title
            gsap.to(".gs-reveal-word", {
                y: "0%",
                duration: 1.2,
                stagger: 0.15,
                ease: "power4.out",
                delay: 0.1
            });

            // Subtle fade up for the subtitle
            gsap.to(".gs-reveal-fade", {
                opacity: 1,
                y: 0,
                duration: 1,
                ease: "power3.out",
                delay: 0.5
            });
        });
    </script>
</body>
</html>
";
    const assetFiles = ["assets/page-01-724142aa-44a6-48d3-9cf3-761e00d05b78-1600w.jpg","assets/page-02-0d868fef-f560-45ca-ab35-5dad4fc29059-3840w.webp","assets/page-03-005600e5-f6ab-4e59-bc86-eaeb02797dfa-1600w.jpg","assets/page-04-3186f9ea-5f5a-49f7-8fcf-568ad52f515e-3840w.webp","assets/page-05-7f78131e-65e9-49b2-aa1f-ccc33e28df9f-1600w.webp","assets/page-06-4f5668c5-fc4a-44e0-bc5e-a664189d3c31-1600w.jpg","assets/page-07-d14dc069-558a-4c51-8aad-5cc237f9b61d-1600w.jpg","assets/page-08-eca707cc-a5b7-439a-b4fd-247f6106c2e1-1600w.jpg","assets/page-09-4734259a-bad7-422f-981e-ce01e79184f2-1600w.jpg","assets/page-10-77415a2e-dcbc-4748-a29d-fced4821881a-1600w.jpg","assets/page-11-5ee0a38a-b5d3-4531-8793-98beed4af162-1600w.jpg","assets/page-12-65695f80-23f9-46ee-8487-cbb6c93cc48b-3840w.webp","assets/page-13-fb6415fd-bf4d-4ccf-8e9d-7ab445e99207-1600w.jpg","assets/page-14-c92852bb-a510-405a-85ab-ffa0fde136a4-1600w.jpg","assets/page-15-e534354d-c5f2-4399-a1d9-2f50338e8c47-1600w.jpg","assets/page-16-2f563338-39fa-47ea-9761-658d4f3f84db-1600w.jpg"];
    const runtimeFiles = ["../../../../assets/runtime/runtime-027051effa47-gsap-min.js","../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js","../../../../assets/runtime/runtime-689ca8dda44c-scrolltrigger-min.js","../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"];
    const frame = document.getElementById("neuform-demo");
    const decodeBytes = (value) => Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
    const decode = (value) => new TextDecoder().decode(decodeBytes(value));
    const encodeBytes = (bytes) => {
      let binary = "";
      for (let index = 0; index < bytes.length; index += 32768) {
        binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
      }
      return btoa(binary);
    };
    const mediaTypes = {
      avif: "image/avif",
      gif: "image/gif",
      jpg: "image/jpeg",
      jpeg: "image/jpeg",
      mp4: "video/mp4",
      png: "image/png",
      webm: "video/webm",
      webp: "image/webp"
    };
    const loadAsset = async (file) => {
      const response = await fetch(file, { cache: "no-store", credentials: "omit", redirect: "error" });
      if (!response.ok) throw new Error("Could not load local demo asset: " + file);
      const extension = file.split(".").pop().toLowerCase();
      const contentType = mediaTypes[extension] || "application/octet-stream";
      const bytes = new Uint8Array(await response.arrayBuffer());
      return { base64: encodeBytes(bytes), contentType, file, kind: "asset" };
    };
    Promise.allSettled(assetFiles.map(loadAsset)).then((results) => {
      const runtimeSources = runtimeFiles.map((file) => new URL(file, location.href).href).join(" ");
      const source = decode(encodedHtml).replace("__NEUFORM_RUNTIME_SOURCES__", runtimeSources);
      const mediaAssets = [];
      for (const result of results) {
        if (result.status !== "fulfilled") continue;
        mediaAssets.push(result.value);
      }
      frame.addEventListener("load", () => {
        frame.contentWindow.postMessage({ type: "neuform-assets-v1", assets: mediaAssets }, "*");
      }, { once: true });
      frame.srcdoc = source;
    }).catch((error) => {
      document.body.innerHTML = '<div class="error">Unable to load this sandboxed demo.</div>';
      console.error(error);
    });
  </script>
</body>
</html>

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Meng To
Publisher
Meng To (Community)
Source
MengTo/Skills · agent-skills/web-design/progressive-blur · commit 5ea1661
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Meng To or Meng To.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download progressive-blur.zip