AutoGineer
Generated banner for Image First Grid Layout
Generated logo for Image First Grid Layout

Image First Grid Layout

Meng ToCommunityCreated by Meng To

  • Skill
  • Guidelines
  • Design and creative
  • MIT
  • Medium risk
Download ZIP

From the author

Create an image-led grid design system with full-bleed photography, structural guide lines, anchored content blocks, and restrained technical overlays.
— the description by Meng To

AutoGineer summary

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

The Image First Grid Layout skill provides a structured approach to designing web experiences where photography or cinematic media serves as the primary stage. It focuses on balancing visual impact with functional UI by using full-bleed imagery, precise structural guide lines, and anchored content blocks. The system emphasizes a restrained aesthetic, utilizing tonal vignettes and subtle technical overlays to maintain readability while ensuring the media remains the dominant element of the composition.

What it does

  • Defines a grid-based system for layering content over full-bleed imagery.
  • Provides patterns for anchored content blocks, such as headlines, CTAs, and secondary metrics.
  • Suggests visual treatments like gradient washes and tonal vignettes for text readability.
  • Outlines the use of structural elements like vertical rails and corner markers to organize the layout.
  • Recommends motion patterns like slow drifts and masked reveals to enhance the cinematic feel.
  • Specifies a restrained color palette and typography style to complement photographic backgrounds.

When to use it

  • When designing hero sections that require a dominant, immersive photographic or cinematic visual.
  • When you need to organize content precisely over an image without using standard stacked marketing sections.
  • When building a product-grade interface that requires a balance between aesthetic impact and structural order.
  • When you want to introduce subtle technical atmosphere, such as faint WebGL lines or additive streaks, to a design.

Advantages

  • Ensures the visual media remains the focal point of the user experience.
  • Provides a clear, intentional structure through visible grid rails and markers.
  • Maintains text readability over complex imagery using measured gradient and overlay techniques.
  • Promotes a cohesive, premium aesthetic through restrained color and typography choices.
  • Prevents visual clutter by anchoring content rather than centering it.

Usage examples

“Design a hero section for a luxury architectural firm using the image-first grid layout.”
The agent will generate a layout plan featuring a full-bleed architectural image, vertical guide rails, and bottom-anchored text blocks with a subtle dark gradient for readability.
“How should I arrange secondary content cards over a cinematic background image?”
The agent will advise using lightly framed, transparent, or low-fill cards that sit on the grid without heavy container chrome to avoid obscuring the image.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/mengto/image-first-grid-layout/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip image-first-grid-layout.zip -d .agents/skills

Documentation by Meng To

Image First Grid Layout Skill

Use When

  • Create an image-led grid design system with full-bleed photography, structural guide lines, anchored content blocks, and restrained technical overlays.

Workflow

Scope

  • Apply this as a full design-system direction across hero image treatment, layout grid, overlay framing, typography, supporting cards, and motion.

  • Use it when the experience should feel led by a dominant photographic or cinematic visual field, with content arranged as precise overlay blocks rather than stacked marketing sections.

  • This is not a gallery layout and not plain editorial minimalism. The image should act as the stage, while the grid and content overlays give it product-grade structure.

Visual target

  • Build the page around a large immersive background image or media surface that fills most or all of the viewport.

  • Add dark gradient washes, directional overlays, or tonal vignettes so text remains readable while the image still feels present and expansive.

  • Use visible structural lines such as outer rails, center guides, and small corner markers to impose order on top of the image field.

  • Anchor the main content low in the viewport or along a deliberate edge so the image retains dominance instead of being crowded by centered UI.

  • Keep the palette restrained and image-responsive: use neutrals, whites, smoke grays, and one subtle accent derived from the image or brand when needed.

Implementation guidance

  • Prefer a full-screen or large-stage hero with the background image treated as a foundational layer, not a small card or thumbnail.

  • Overlay the image with a measured grid system using vertical container lines, subtle framing guides, or a split-column scaffold that remains visible but quiet.

  • Place the primary headline and CTA group in one anchored grid column, then use a secondary box for quote, proof, metric, or supporting narrative in another.

  • Supporting cards should feel lightly framed and transparent or low-fill, so they sit on top of the image instead of fighting it with heavy container chrome.

  • Introduce subtle technical atmosphere when useful, such as faint WebGL lines, additive streaks, slow background motion, or minimal parallax over the image plane.

  • Typography should stay clean and premium: confident sans-serif headlines, soft low-contrast body copy, and restrained micro-labels or nav text.

  • Motion should emphasize reveal and drift rather than busy interaction, using masked text entrances, slow line movement, and gentle hover sweeps.

Recommended patterns

  • Full-bleed landscape or architectural image with layered left-to-right and bottom-up dark gradients for readability.

  • Vertical guide rails with tiny square markers or subtle boundary points running through the stage.

  • Bottom-anchored hero copy paired with a secondary quote, testimonial, or metric box floating in an adjacent grid lane.

  • Sparse top navigation with a light transparent shell so the image remains the main event.

  • Faint WebGL or canvas line field drifting over the image in screen or additive blend mode.

  • Buttons that use translucent dark fills, thin borders, and small moving highlight sweeps instead of loud color blocks.

Tuning knobs

  • Image dominance: let the media occupy nearly the whole experience, then scale content density around it rather than the other way around.

  • Overlay darkness: adjust gradient strength until readability is strong without flattening the image.

  • Grid visibility: make the rails and markers just visible enough to feel intentional, not heavy enough to distract from the photography.

  • Technical atmosphere: add or remove subtle animated lines or glow depending on how product-like versus purely cinematic the page should feel.

  • Content anchoring: shift copy and secondary boxes left, right, or lower in the viewport to preserve strong negative space.

Avoid

  • Turning the image into a decorative background behind a conventional centered SaaS layout.

  • Overfilling the viewport with cards, widgets, or text that erase the image-first composition.

  • Bright multi-color accents that break the calm, cinematic tone of the stage.

  • Heavy solid containers that sever the relationship between the overlays and the underlying image.

  • Treating the grid as invisible; the structure should quietly organize the composition.

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" class="scroll-smooth">
<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>Kiwi Floral | Artisan Botanical Design</title>
    
    <!-- Fonts -->
    <link rel="preconnect" href="https://fonts.googleapis.com">
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500&family=Playfair+Display:ital,wght@0,400;0,500;1,400&display=swap" rel="stylesheet">
    
    <!-- Tailwind CSS -->
    <script src="../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"></script>
    
    <!-- Tailwind Config for specific font families -->
    <script>
        tailwind.config = {
            theme: {
                extend: {
                    fontFamily: {
                        sans: ['Inter', 'sans-serif'],
                        serif: ['"Playfair Display"', 'serif'],
                    },
                    colors: {
                        brand: {
                            bg: '#F6F5F2',
                            text: '#1C201C',
                            muted: '#767873',
                            dark: '#1B241A',
                        }
                    }
                }
            }
        }
    </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>
</head>
<body class="bg-brand-bg text-brand-text font-sans antialiased overflow-x-hidden selection:bg-brand-dark selection:text-white">

    <!-- Container Lines Wrapper -->
    <div class="relative max-w-[1400px] mx-auto border-x border-black/5 min-h-screen flex flex-col bg-brand-bg">
        
        <!-- Corner Markers -->
        <div class="absolute top-0 -left-[3px] w-[5px] h-[5px] border border-black/15 bg-brand-bg z-50"></div>
        <div class="absolute top-0 -right-[3px] w-[5px] h-[5px] border border-black/15 bg-brand-bg z-50"></div>

        <!-- IMAGE FIRST GRID HERO -->
        <main class="relative w-full h-[95vh] min-h-[700px] flex flex-col border-b border-black/5 overflow-hidden">
            <!-- Immersive Background -->
            <img src="assets/page-01-65695f80-23f9-46ee-8487-cbb6c93cc48b-3840w.webp" alt="Botanical elegance" class="absolute inset-0 w-full h-full object-cover object-top scale-105" style="transform-origin: top center;">
            
            <!-- Dark Gradient Washes -->
            <div class="absolute inset-0" style="background: linear-gradient(to top, rgba(10,12,10,0.95) 0%, rgba(10,12,10,0.4) 40%, rgba(10,12,10,0.1) 100%);"></div>
            
            <!-- Visible Grid Lines -->
            <div class="absolute inset-0 flex justify-between px-6 md:px-12 pointer-events-none z-0 opacity-20">
                <div class="w-[1px] h-full bg-white"></div>
                <div class="w-[1px] h-full bg-white hidden md:block"></div>
                <div class="w-[1px] h-full bg-white hidden lg:block"></div>
                <div class="w-[1px] h-full bg-white"></div>
            </div>

            <!-- Header (Floating over Image) -->
            <header class="w-full flex items-center justify-between px-6 py-8 md:px-12 relative z-20 text-white/90">
                <nav class="hidden md:flex items-center gap-8 text-sm font-light">
                    <a href="#" class="hover:text-white transition-colors">Collections</a>
                    <a href="#" class="hover:text-white transition-colors">Philosophy</a>
                    <a href="#" class="hover:text-white transition-colors">Journal</a>
                </nav>
                
                <a href="#" class="absolute left-1/2 -translate-x-1/2 flex items-center gap-2 text-xl font-serif tracking-tight text-white">
                    <iconify-icon icon="solar:leaf-line-duotone" width="24" height="24" stroke-width="1.5"></iconify-icon>
                    KIWI FLORAL
                </a>

                <div class="flex items-center gap-6 text-sm font-light">
                    <a href="#" class="hidden md:block hover:text-white transition-colors">Login</a>
                    <!-- Skeuomorphic Button -->
                    <a href="#" class="text-white px-5 py-2.5 rounded-full flex items-center gap-2 transition-all" style="background: linear-gradient(180deg, rgba(255,255,255,0.15) 0%, rgba(255,255,255,0.05) 100%); box-shadow: inset 0 1px 1px rgba(255,255,255,0.2), inset 0 -1px 1px rgba(0,0,0,0.3), 0 4px 12px rgba(0,0,0,0.2); border: 1px solid rgba(255,255,255,0.1);">
                        Order Now
                        <iconify-icon icon="solar:arrow-right-linear" width="16" height="16"></iconify-icon>
                    </a>
                </div>
            </header>

            <!-- Bottom Anchored Grid Content -->
            <div class="relative flex-grow flex items-end pb-16 px-6 md:px-12 z-10">
                <div class="grid grid-cols-1 md:grid-cols-12 gap-8 w-full items-end">
                    
                    <div class="md:col-span-8 lg:col-span-7">
                        <div class="flex items-center gap-6 text-white/50 mb-8">
                            <iconify-icon icon="solar:star-fall-linear" width="20" height="20"></iconify-icon>
                            <span class="text-xs tracking-widest uppercase font-normal">Vogue</span>
                            <span class="text-xs tracking-widest uppercase font-normal">Kinfolk</span>
                            <span class="text-xs tracking-widest uppercase font-normal">Cereal</span>
                        </div>
                        <h1 class="font-serif text-5xl md:text-7xl lg:text-[5.5rem] leading-[1.05] tracking-tight text-white reveal-text drop-shadow-lg">
                            Artisan Floristry for Meaningful Moments
                        </h1>
                    </div>

                    <div class="md:col-span-4 lg:col-span-4 lg:col-start-9 flex flex-col justify-end">
                        <!-- Translucent Grid Box -->
                        <div class="bg-white/5 backdrop-blur-md p-[1px] rounded-2xl" style="background: linear-gradient(145deg, rgba(255,255,255,0.2) 0%, rgba(255,255,255,0.02) 100%);">
                            <div class="bg-black/40 rounded-[calc(1rem-1px)] p-6 md:p-8 flex flex-col gap-6">
                                <p class="text-sm text-white/80 font-light leading-relaxed">
                                    Curated botanical arrangements designed to elevate your space and optimize emotional well-being. No synthetic fillers. Pure natural beauty.
                                </p>
                                <a href="#" class="inline-flex items-center justify-between group border-b border-white/20 pb-2 text-white hover:border-white/60 transition-colors">
                                    <span class="text-sm font-normal">View Collections</span>
                                    <iconify-icon icon="solar:arrow-right-up-linear" width="18" height="18" class="group-hover:translate-x-1 group-hover:-translate-y-1 transition-transform"></iconify-icon>
                                </a>
                            </div>
                        </div>
                    </div>
                    
                </div>
            </div>
        </main>

        <!-- SPLIT LAYOUT SECTION: Philosophy -->
        <section class="w-full border-b border-black/5 flex flex-col md:flex-row bg-brand-bg relative z-10">
            <!-- Left Panel: Technical/Editorial -->
            <div class="w-full md:w-1/2 p-8 md:p-16 lg:p-24 border-b md:border-b-0 md:border-r border-black/5 flex flex-col justify-between">
                <div>
                    <div class="flex items-center gap-4 mb-16">
                        <div class="w-2 h-2 bg-brand-text"></div>
                        <span class="text-xs font-mono tracking-widest uppercase text-brand-muted">01 // Architecture</span>
                    </div>
                    
                    <h2 class="text-4xl md:text-5xl font-serif tracking-tight text-brand-text mb-8 reveal-text leading-[1.1]">
                        Engineered Botanical Elegance.
                    </h2>
                    
                    <p class="text-base text-brand-muted font-light leading-relaxed mb-12 max-w-md">
                        Every stem is selected through a rigorous botanical protocol, ensuring spatial harmony and sustained vitality. We bridge the gap between organic unpredictability and architectural precision.
                    </p>
                </div>

                <!-- Skeuomorphic Spec Card -->
                <div class="p-[1px] rounded-[1.5rem] mt-12 md:mt-24 max-w-sm" style="background: linear-gradient(180deg, rgba(0,0,0,0.08) 0%, rgba(0,0,0,0.01) 100%);">
                    <div class="rounded-[calc(1.5rem-1px)] p-6 relative overflow-hidden" style="background: linear-gradient(180deg, #FFFFFF 0%, #F8F7F4 100%); box-shadow: inset 0 2px 4px rgba(255,255,255,1), inset 0 -1px 2px rgba(0,0,0,0.03), 0 8px 20px rgba(0,0,0,0.03);">
                        <!-- Highlight Edge -->
                        <div class="absolute top-0 left-0 w-full h-[1px] bg-gradient-to-r from-transparent via-white to-transparent opacity-80"></div>
                        
                        <div class="flex justify-between items-center mb-4">
                            <h4 class="text-sm font-normal text-brand-text tracking-tight">Sustainable Sourcing</h4>
                            <iconify-icon icon="solar:leaf-linear" width="20" height="20" class="text-brand-muted"></iconify-icon>
                        </div>
                        <p class="text-xs text-brand-muted font-light leading-relaxed">
                            Direct partnerships with regenerative micro-farms guarantee zero synthetic interference, maximizing vase life organically.
                        </p>
                    </div>
                </div>
            </div>

            <!-- Right Panel: Immersive Media & Specs -->
            <div class="w-full md:w-1/2 relative bg-[#151914] min-h-[500px] flex items-center justify-center p-8 md:p-16 overflow-hidden">
                <img src="assets/page-02-724142aa-44a6-48d3-9cf3-761e00d05b78-1600w.jpg" alt="Architectural Structure" class="absolute inset-0 w-full h-full object-cover opacity-50 mix-blend-luminosity">
                <div class="absolute inset-0 bg-gradient-to-b from-transparent to-[#151914]/80"></div>
                
                <!-- Spec Table Overlaid -->
                <div class="relative z-10 w-full max-w-md bg-black/20 backdrop-blur-md border border-white/10 rounded-2xl p-8">
                    <h3 class="text-lg font-serif tracking-tight text-white mb-6">Technical Parameters</h3>
                    <div class="space-y-4">
                        <div class="flex justify-between items-end border-b border-white/10 pb-3">
                            <span class="text-xs font-mono text-white/50 uppercase tracking-widest">Sourcing Radius</span>
                            <span class="text-sm font-light text-white">Under 50 Miles</span>
                        </div>
                        <div class="flex justify-between items-end border-b border-white/10 pb-3">
                            <span class="text-xs font-mono text-white/50 uppercase tracking-widest">Preservation</span>
                            <span class="text-sm font-light text-white">Climate-Sealed</span>
                        </div>
                        <div class="flex justify-between items-end border-b border-white/10 pb-3">
                            <span class="text-xs font-mono text-white/50 uppercase tracking-widest">Curation Time</span>
                            <span class="text-sm font-light text-white">48 Hours</span>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Collections: 3 Column Grid -->
        <main class="w-full pt-24 pb-32 px-6 md:px-12 bg-brand-bg relative z-10 border-b border-black/5">
            <div class="flex flex-col items-center text-center mb-16">
                <div class="text-xs font-mono tracking-widest uppercase text-brand-muted mb-4">02 // The Collections</div>
                <h2 class="font-serif text-4xl md:text-5xl tracking-tight text-brand-text reveal-text">
                    Curated Arrangements
                </h2>
            </div>

            <div class="w-full grid grid-cols-1 md:grid-cols-3 gap-6 text-left">
                
                <!-- Card 1: Image -->
                <div class="h-[500px] md:h-[600px] rounded-[2rem] overflow-hidden relative group shadow-sm">
                    <img src="assets/page-03-4734259a-bad7-422f-981e-ce01e79184f2-1600w.jpg" alt="Abstract floral interpretation" class="w-full h-full object-cover group-hover:scale-105 transition-transform duration-1000 ease-out">
                    <div class="absolute bottom-6 left-6 bg-white/20 backdrop-blur-md px-4 py-2 rounded-full border border-white/30 flex items-center gap-2 text-white text-xs font-light">
                        <iconify-icon icon="solar:sun-2-linear" width="14" height="14"></iconify-icon>
                        Morning Harvest
                    </div>
                </div>

                <!-- Card 2: Highly Skeuomorphic UI Card -->
                <div class="h-[500px] md:h-[600px] rounded-[2rem] relative z-10 p-[1px]" style="background: linear-gradient(145deg, rgba(0,0,0,0.1) 0%, rgba(0,0,0,0.01) 100%);">
                    <!-- Layered depth container -->
                    <div class="rounded-[calc(2rem-1px)] h-full p-8 flex flex-col justify-between relative overflow-hidden" style="background: linear-gradient(180deg, #FFFFFF 0%, #F5F4F1 100%); box-shadow: inset 0 2px 3px rgba(255,255,255,1), inset 0 -2px 6px rgba(0,0,0,0.03), 0 10px 30px rgba(0,0,0,0.05);">
                        
                        <!-- Skeuomorphic Top Highlight -->
                        <div class="absolute top-0 left-0 w-full h-[1px] bg-gradient-to-r from-transparent via-white to-transparent opacity-80"></div>

                        <div>
                            <div class="flex justify-between items-start mb-8">
                                <div class="w-12 h-12 rounded-full flex items-center justify-center text-brand-dark" style="background: linear-gradient(180deg, #F6F5F2 0%, #EBE9E4 100%); box-shadow: inset 0 1px 2px rgba(255,255,255,0.9), 0 2px 4px rgba(0,0,0,0.05); border: 1px solid rgba(0,0,0,0.03);">
                                    <iconify-icon icon="solar:box-linear" width="22" height="22"></iconify-icon>
                                </div>
                                <button class="w-10 h-10 rounded-full flex items-center justify-center text-brand-muted hover:text-red-500 transition-colors" style="background: linear-gradient(180deg, #FFFFFF 0%, #F6F5F2 100%); box-shadow: inset 0 1px 1px rgba(255,255,255,1), 0 2px 5px rgba(0,0,0,0.04); border: 1px solid rgba(0,0,0,0.02);">
                                    <iconify-icon icon="solar:heart-linear" width="20" height="20"></iconify-icon>
                                </button>
                            </div>
                            <h3 class="text-2xl font-serif tracking-tight text-brand-text mb-3 drop-shadow-[0_1px_1px_rgba(255,255,255,1)]">The Ethereal Bouquet</h3>
                            <p class="text-sm text-brand-muted font-light leading-relaxed">Rich in textural diversity for spatial balance. Engineered to evolve gracefully over its lifespan.</p>
                        </div>

                        <div class="space-y-4">
                            <div class="flex justify-between items-end border-b border-black/5 pb-3">
                                <span class="text-xs font-mono uppercase tracking-widest text-brand-muted/70">Longevity</span>
                                <span class="text-sm font-light text-brand-text drop-shadow-[0_1px_0_rgba(255,255,255,0.8)]">10-14 days</span>
                            </div>
                            <div class="flex justify-between items-end border-b border-black/5 pb-3">
                                <span class="text-xs font-mono uppercase tracking-widest text-brand-muted/70">Scent Profile</span>
                                <span class="text-sm font-light text-brand-text drop-shadow-[0_1px_0_rgba(255,255,255,0.8)]">Subtle Jasmine</span>
                            </div>
                            <div class="flex justify-between items-end border-b border-black/5 pb-3">
                                <span class="text-xs font-mono uppercase tracking-widest text-brand-muted/70">Vase Life Setup</span>
                                <span class="text-sm font-light text-brand-text drop-shadow-[0_1px_0_rgba(255,255,255,0.8)]">Pre-trimmed</span>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Card 3: Image -->
                <div class="h-[500px] md:h-[600px] rounded-[2rem] overflow-hidden relative group shadow-sm">
                    <img src="assets/page-04-005600e5-f6ab-4e59-bc86-eaeb02797dfa-1600w.jpg" alt="Botanical architecture" class="w-full h-full object-cover group-hover:scale-105 transition-transform duration-1000 ease-out">
                    <div class="absolute inset-0" style="background: linear-gradient(to top, rgba(27,36,26,0.8) 0%, transparent 60%);"></div>
                    <div class="absolute bottom-8 left-8 right-8">
                        <p class="text-white text-xl font-serif tracking-tight leading-snug">
                            Complete natural elegance sourced directly from sustainable growers.
                        </p>
                    </div>
                </div>

            </div>
        </main>

        <!-- Quote Section -->
        <section class="w-full bg-white py-32 md:py-48 border-b border-black/5 relative overflow-hidden">
            <div class="absolute inset-0 flex justify-center pointer-events-none opacity-[0.03]">
                <div class="w-[1px] h-full bg-black mx-10"></div>
                <div class="w-[1px] h-full bg-black mx-10"></div>
            </div>
            
            <div class="max-w-4xl mx-auto px-6 text-center relative z-10">
                <iconify-icon icon="solar:quote-right-linear" width="48" height="48" class="text-brand-muted/20 mb-8 mx-auto block"></iconify-icon>
                <h2 class="font-serif text-3xl md:text-5xl lg:text-6xl tracking-tight leading-tight text-brand-text reveal-text">
                    "A systemic protocol engineered to restore spatial harmony and deliver sustained vitality without synthetic compromise."
                </h2>
            </div>
        </section>

        <!-- Slider Section -->
        <section class="w-full pt-24 pb-32 px-6 md:px-12 bg-brand-bg relative border-b border-black/5">
            <div class="flex items-end justify-between mb-12">
                <div>
                    <div class="text-xs font-mono tracking-widest uppercase text-brand-muted mb-2">03 // Components</div>
                    <h2 class="font-serif text-3xl md:text-4xl tracking-tight text-brand-text">Core Botanicals</h2>
                </div>
                <div class="hidden md:flex gap-3">
                    <button class="w-12 h-12 rounded-full flex items-center justify-center text-brand-text transition-all hover:-translate-y-0.5" style="background: linear-gradient(180deg, #FFFFFF 0%, #F6F5F2 100%); box-shadow: inset 0 1px 1px rgba(255,255,255,1), 0 4px 10px rgba(0,0,0,0.05); border: 1px solid rgba(0,0,0,0.03);">
                        <iconify-icon icon="solar:arrow-left-linear" width="20" height="20"></iconify-icon>
                    </button>
                    <button class="w-12 h-12 rounded-full flex items-center justify-center text-brand-text transition-all hover:-translate-y-0.5" style="background: linear-gradient(180deg, #FFFFFF 0%, #F6F5F2 100%); box-shadow: inset 0 1px 1px rgba(255,255,255,1), 0 4px 10px rgba(0,0,0,0.05); border: 1px solid rgba(0,0,0,0.03);">
                        <iconify-icon icon="solar:arrow-right-linear" width="20" height="20"></iconify-icon>
                    </button>
                </div>
            </div>

            <div class="flex gap-6 overflow-x-auto pb-8 snap-x snap-mandatory scrollbar-hide" style="scrollbar-width: none;">
                
                <div class="min-w-[300px] md:min-w-[380px] snap-start flex flex-col gap-5">
                    <div class="aspect-[4/5] rounded-[2rem] overflow-hidden p-2" style="background: linear-gradient(180deg, #FFFFFF 0%, #F8F7F4 100%); box-shadow: inset 0 2px 4px rgba(255,255,255,1), 0 8px 20px rgba(0,0,0,0.04); border: 1px solid rgba(0,0,0,0.02);">
                         <img src="assets/page-02-724142aa-44a6-48d3-9cf3-761e00d05b78-1600w.jpg" alt="Structure" class="w-full h-full object-cover rounded-[1.5rem]">
                    </div>
                    <div class="px-2">
                        <h4 class="text-base font-normal text-brand-text tracking-tight">Structural Stems</h4>
                        <p class="text-xs text-brand-muted mt-1 font-light">Foundation Architecture</p>
                    </div>
                </div>

                <div class="min-w-[300px] md:min-w-[380px] snap-start flex flex-col gap-5">
                    <div class="aspect-[4/5] rounded-[2rem] overflow-hidden p-2" style="background: linear-gradient(180deg, #FFFFFF 0%, #F8F7F4 100%); box-shadow: inset 0 2px 4px rgba(255,255,255,1), 0 8px 20px rgba(0,0,0,0.04); border: 1px solid rgba(0,0,0,0.02);">
                         <img src="assets/page-04-005600e5-f6ab-4e59-bc86-eaeb02797dfa-1600w.jpg" alt="Lush" class="w-full h-full object-cover rounded-[1.5rem]">
                    </div>
                    <div class="px-2">
                        <h4 class="text-base font-normal text-brand-text tracking-tight">Verdant Foliage</h4>
                        <p class="text-xs text-brand-muted mt-1 font-light">Spatial Volume</p>
                    </div>
                </div>

                <div class="min-w-[300px] md:min-w-[380px] snap-start flex flex-col gap-5">
                    <div class="aspect-[4/5] rounded-[2rem] overflow-hidden p-2" style="background: linear-gradient(180deg, #FFFFFF 0%, #F8F7F4 100%); box-shadow: inset 0 2px 4px rgba(255,255,255,1), 0 8px 20px rgba(0,0,0,0.04); border: 1px solid rgba(0,0,0,0.02);">
                         <img src="assets/page-05-e534354d-c5f2-4399-a1d9-2f50338e8c47-1600w.jpg" alt="Flow" class="w-full h-full object-cover rounded-[1.5rem]">
                    </div>
                    <div class="px-2">
                        <h4 class="text-base font-normal text-brand-text tracking-tight">Statement Blooms</h4>
                        <p class="text-xs text-brand-muted mt-1 font-light">Visual Focal Point</p>
                    </div>
                </div>

                 <div class="min-w-[300px] md:min-w-[380px] snap-start flex flex-col gap-5">
                    <div class="aspect-[4/5] rounded-[2rem] overflow-hidden p-2" style="background: linear-gradient(180deg, #FFFFFF 0%, #F8F7F4 100%); box-shadow: inset 0 2px 4px rgba(255,255,255,1), 0 8px 20px rgba(0,0,0,0.04); border: 1px solid rgba(0,0,0,0.02);">
                         <img src="assets/page-06-fb6415fd-bf4d-4ccf-8e9d-7ab445e99207-1600w.jpg" alt="Accent" class="w-full h-full object-cover rounded-[1.5rem]">
                    </div>
                    <div class="px-2">
                        <h4 class="text-base font-normal text-brand-text tracking-tight">Textural Accents</h4>
                        <p class="text-xs text-brand-muted mt-1 font-light">Micro Details</p>
                    </div>
                </div>

            </div>
        </section>

        <!-- LUXURIOUS FOOTER -->
        <footer class="w-full bg-brand-dark text-white pt-24 pb-12 px-6 md:px-12 relative flex-grow flex flex-col justify-end">
            <div class="grid grid-cols-1 md:grid-cols-2 gap-16 mb-24">
                <div>
                    <a href="#" class="flex items-center gap-2 text-2xl font-serif tracking-tight text-white mb-8">
                        <iconify-icon icon="solar:leaf-line-duotone" width="28" height="28" stroke-width="1.5"></iconify-icon>
                        KIWI FLORAL
                    </a>
                    <p class="text-sm text-white/50 font-light max-w-sm leading-relaxed">
                        Redefining botanical integration for modern spaces. Engineered nature without compromise.
                    </p>
                </div>
                
                <div class="grid grid-cols-2 gap-8">
                    <div>
                        <h4 class="text-xs font-mono uppercase tracking-widest text-white/40 mb-6">Index</h4>
                        <ul class="space-y-4 text-sm font-light text-white/80">
                            <li><a href="#" class="hover:text-white transition-colors">Collections</a></li>
                            <li><a href="#" class="hover:text-white transition-colors">Philosophy</a></li>
                            <li><a href="#" class="hover:text-white transition-colors">Sourcing</a></li>
                            <li><a href="#" class="hover:text-white transition-colors">Journal</a></li>
                        </ul>
                    </div>
                    <div>
                        <h4 class="text-xs font-mono uppercase tracking-widest text-white/40 mb-6">Connect</h4>
                        <ul class="space-y-4 text-sm font-light text-white/80">
                            <li><a href="#" class="hover:text-white transition-colors">Instagram</a></li>
                            <li><a href="#" class="hover:text-white transition-colors">Pinterest</a></li>
                            <li><a href="#" class="hover:text-white transition-colors">Contact</a></li>
                        </ul>
                    </div>
                </div>
            </div>

            <div class="flex flex-col md:flex-row justify-between items-center pt-8 border-t border-white/10 text-xs font-mono text-white/30">
                <p>&copy; 2024 Kiwi Floral System. All rights reserved.</p>
                <div class="flex gap-6 mt-4 md:mt-0">
                    <a href="#" class="hover:text-white/60 transition-colors">Privacy</a>
                    <a href="#" class="hover:text-white/60 transition-colors">Terms</a>
                </div>
            </div>
        </footer>

        <!-- Bottom Corner Markers -->
        <div class="absolute bottom-0 -left-[3px] w-[5px] h-[5px] border border-black/15 bg-brand-bg z-50"></div>
        <div class="absolute bottom-0 -right-[3px] w-[5px] h-[5px] border border-black/15 bg-brand-bg z-50"></div>
    </div>

    <!-- WebGL & GSAP Animation Logic -->
    <script>
        document.addEventListener("DOMContentLoaded", () => {
            gsap.registerPlugin(ScrollTrigger);

            const setupTextReveal = () => {
                const revealElements = document.querySelectorAll('.reveal-text');
                
                revealElements.forEach(el => {
                    const text = el.innerText;
                    el.innerHTML = '';
                    const words = text.split(' ');
                    
                    words.forEach(word => {
                        const maskDiv = document.createElement('span');
                        maskDiv.style.display = 'inline-flex';
                        maskDiv.style.overflow = 'hidden';
                        maskDiv.style.verticalAlign = 'top';
                        maskDiv.style.paddingRight = '0.25em';
                        maskDiv.style.paddingBottom = '0.1em';

                        const innerSpan = document.createElement('span');
                        innerSpan.innerText = word;
                        innerSpan.style.display = 'inline-block';
                        innerSpan.style.transform = 'translateY(110%) rotate(4deg)';
                        innerSpan.style.transformOrigin = 'top left';
                        innerSpan.classList.add('reveal-word-inner');

                        maskDiv.appendChild(innerSpan);
                        el.appendChild(maskDiv);
                    });

                    gsap.to(el.querySelectorAll('.reveal-word-inner'), {
                        y: '0%',
                        rotate: 0,
                        duration: 1.2,
                        stagger: 0.03,
                        ease: 'power4.out',
                        scrollTrigger: {
                            trigger: el,
                            start: 'top 90%',
                            toggleActions: 'play none none reverse'
                        }
                    });
                });
            };

            setTimeout(setupTextReveal, 100);
        });
    </script>
</body>
</html>
";
    const assetFiles = ["assets/page-01-65695f80-23f9-46ee-8487-cbb6c93cc48b-3840w.webp","assets/page-02-724142aa-44a6-48d3-9cf3-761e00d05b78-1600w.jpg","assets/page-03-4734259a-bad7-422f-981e-ce01e79184f2-1600w.jpg","assets/page-04-005600e5-f6ab-4e59-bc86-eaeb02797dfa-1600w.jpg","assets/page-05-e534354d-c5f2-4399-a1d9-2f50338e8c47-1600w.jpg","assets/page-06-fb6415fd-bf4d-4ccf-8e9d-7ab445e99207-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/image-first-grid-layout · 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.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download image-first-grid-layout.zip