AutoGineer
Generated banner for Container Lines
Generated logo for Container Lines

Container Lines

Meng ToCommunityCreated by Meng To

  • Skill
  • Guidelines
  • Software development
  • MIT
  • Medium risk
Download ZIP

From the author

Add vertical container-size guide lines with mini corner squares for precise, structured web layouts. Use when asked for container lines, measured layout guides, vertical boundary lines, editorial grid markers, or small corner-square frame details.
— the description by Meng To

AutoGineer summary

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

This skill provides a standardized approach to adding technical, editorial-style grid markers to web layouts. By using CSS pseudo-elements and specific container logic, it allows developers to draw thin vertical lines and corner squares that frame content without interfering with user interaction. The system emphasizes subtle visual tension, ensuring that layout guides remain unobtrusive while providing a precise, measured aesthetic for hero sections or main content areas.

What it does

  • Defines CSS variables for consistent container widths and line styling.
  • Implements vertical boundary lines using pseudo-elements on a layout shell.
  • Provides a structure for adding mini corner squares to section intersections.
  • Ensures layout guides are non-interactive by disabling pointer events.
  • Maintains alignment between content containers and visual guide markers.
  • Offers best practices for maintaining visual subtlety and layout consistency.

When to use it

  • When a web page requires subtle vertical guides to define content boundaries.
  • To add structural tension to hero sections or product pages that feel too loose.
  • When the design calls for a technical, measured, or industrial aesthetic.
  • To implement editorial-style grid markers or corner frame details.

Advantages

  • Non-intrusive design that does not block UI interactions.
  • Highly consistent visual system across different page sections.
  • Uses lightweight CSS without requiring heavy external dependencies.
  • Provides a clean, professional, and structured look for web layouts.

Usage examples

“Add vertical container lines to my main layout shell.”
The agent applies the .container-lines class to the main element and sets up the CSS pseudo-elements to draw thin vertical lines aligned with the content container.
“How can I add corner markers to my hero section?”
The agent provides the .corner-squares HTML structure and the corresponding CSS to place small squares at the corners of the section.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/mengto/container-lines/download

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

    mkdir -p .agents/skills && unzip container-lines.zip -d .agents/skills

Documentation by Meng To

Container Lines

Use When

  • A page needs subtle vertical guides that reveal the content container width.

  • A hero, section, or product page feels too loose and needs structural tension.

  • The design calls for mini corner squares, measured edges, or quiet technical framing.

Rules

  1. Draw lines at the left and right edges of the main content container.

  2. Keep lines thin: 1px with low opacity.

  3. Add mini squares at container corners or section intersections.

  4. Keep the line system consistent across sections; do not change width per section.

  5. Place lines behind content but above the page background.

  6. Disable pointer events so the guides never block UI.

Base Tokens

:root {
  --container-max: 1120px;
  --container-pad: clamp(20px, 4vw, 48px);
  --line-color: rgba(24, 24, 27, 0.14);
  --line-strong: rgba(24, 24, 27, 0.28);
  --corner-size: 6px;
}

Page Container Lines

Use pseudo-elements on the layout shell.

.container-lines {
  position: relative;
  isolation: isolate;
}

.container-lines::before,
.container-lines::after {
  content: "";
  position: absolute;
  top: 0;
  bottom: 0;
  z-index: -1;
  width: 1px;
  background: var(--line-color);
  pointer-events: none;
}

.container-lines::before {
  left: max(var(--container-pad), calc((100vw - var(--container-max)) / 2));
}

.container-lines::after {
  right: max(var(--container-pad), calc((100vw - var(--container-max)) / 2));
}

Corner Squares

Add four small squares to sections that need a precise measured feel.

.corner-squares {
  position: relative;
}

.corner-squares > .corner {
  position: absolute;
  width: var(--corner-size);
  height: var(--corner-size);
  background: var(--line-strong);
  pointer-events: none;
}

.corner.top-left { top: 0; left: 0; transform: translate(-50%, -50%); }
.corner.top-right { top: 0; right: 0; transform: translate(50%, -50%); }
.corner.bottom-left { bottom: 0; left: 0; transform: translate(-50%, 50%); }
.corner.bottom-right { right: 0; bottom: 0; transform: translate(50%, 50%); }
<main class="container-lines">
  <section class="corner-squares">
    <span class="corner top-left"></span>
    <span class="corner top-right"></span>
    <span class="corner bottom-left"></span>
    <span class="corner bottom-right"></span>
    ...
  </section>
</main>

Minimal Section Wrapper

Use the same container width as the line positions.

.content-container {
  width: min(100% - (var(--container-pad) * 2), var(--container-max));
  margin-inline: auto;
}

Taste Rules

  • Use lines as structure, not decoration. They should organize the page quietly.

  • Do not add lines to every nested component; keep them at page or major-section level.

  • Mini squares should be small and exact, usually 4px to 8px.

  • Avoid bright accent colors unless the entire visual system is technical or industrial.

  • Keep container max-width and padding shared between content and guide lines.

Quick Checks

  • The vertical lines align exactly with the content container edges.

  • Corner squares sit on real container or section corners, not arbitrary positions.

  • Lines remain subtle on light and dark backgrounds.

  • Mobile still has enough padding between the line and content.

  • Guides do not intercept clicks, hovers, or text selection.

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/container-lines · 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 container-lines.zip