Nested Container Clean Agency

Meng ToCommunityCreated by Meng To

Skill
Content generator
Design and creative
MIT
Medium risk

From the author

Create a clean agency design system built from nested containers, with an outer editorial shell, inset dark feature blocks, rounded premium cards, and restrained accent color.

— 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 building clean, high-end agency websites by prioritizing nested container architecture over flat layouts. It focuses on establishing a clear visual hierarchy through an outer editorial shell, inset dark feature blocks, and rounded premium cards. By emphasizing generous whitespace, restrained accent usage, and intentional layering, the system ensures a sophisticated and breathable interface that avoids the clutter of generic card-grid designs.

What it does

Defines a global page frame using outer wrappers with vertical rails and corner markers.
Provides patterns for nesting dark feature blocks within lighter editorial shells.
Establishes guidelines for premium card styling using gradient borders and soft shadows.
Sets rules for restrained accent color application to maintain a professional tone.
Offers tuning knobs for adjusting nesting depth, contrast balance, and container density.
Outlines spacing and alignment strategies to ensure a breathable, intentional layout.

When to use it

When designing a high-end agency or portfolio website that requires a premium feel.
When you want to move away from flat, generic section-based layouts.
When building complex pricing or feature comparison pages that need clear visual grouping.
When you need a consistent design system that balances editorial content with interactive UI elements.

Advantages

Creates a strong, sophisticated visual hierarchy through intentional container nesting.
Prevents layout clutter by enforcing generous whitespace and restrained styling.
Provides a modular approach to building complex page sections.
Ensures a consistent, polished aesthetic across different page components.

Usage examples

“Apply the nested container design system to a new agency landing page.”: The agent will structure the page with an outer editorial shell, incorporate a dark inset section for service highlights, and use rounded cards for pricing tiers.
“How should I style my pricing section to match the clean agency aesthetic?”: The agent will recommend nesting the pricing cards within a dark, rounded feature block inside the main page shell, using subtle accent colors for call-to-action buttons.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/mengto/nested-container-clean-agency/download

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

mkdir -p .agents/skills && unzip nested-container-clean-agency.zip -d .agents/skills

Documentation by Meng To

Nested Container Clean Agency Skill

Use When

Create a clean agency design system built from nested containers, with an outer editorial shell, inset dark feature blocks, rounded premium cards, and restrained accent color.

Workflow

Scope

Apply this as a full design-system direction across page shell, section framing, cards, pricing blocks, call-to-action areas, and layout rhythm.
Use it when the interface should feel clean, premium, and agency-led, with strong container hierarchy instead of flat page sections.
This is not generic card-grid SaaS and not only a framing utility. The whole composition should be organized through nested shells and inset feature blocks.

Visual target

Start with a centered outer page container that defines the main boundaries of the design with visible vertical rails, corner squares, or light frame lines.
Inside that outer shell, place one or more inset containers with contrasting surfaces, especially dark rounded feature zones nested within a light editorial page.
Build hierarchy by stacking containers inside containers: outer shell, inner dark section, then smaller rounded cards or content panels inside that section.
Keep typography clean, modern, and agency-like, with confident headlines, restrained body copy, and minimal UI noise.
Use a soft accent color sparingly for pills, buttons, active dots, subtle gradients, and call-to-action emphasis rather than saturating the full layout.

Implementation guidance

Prefer a max-width outer wrapper with consistent side padding, vertical boundary lines, and tiny corner markers to establish the global frame.
Use nested rounded containers to create depth: a darker major block inside the page, then lighter or darker cards inset within it depending on contrast needs.
Maintain generous whitespace between nested layers so each shell feels intentional and breathable.
Use border gradients, low-contrast strokes, and soft shadows to separate layers instead of heavy outlines everywhere.
Pricing sections, service groupings, or feature comparisons should feel like modular editorial blocks housed inside a larger premium container.
Motion should stay minimal and polished: masked text reveals, calm fade-ins, and light hover transitions are enough.

Recommended patterns

White or off-white outer shell with border-x rails and tiny corner squares defining the page bounds.
Large dark rounded section acting as a featured pricing or capability block nested within the lighter page shell.
Premium inner cards with gradient-border wrappers, soft surface contrast, and clear content grouping.
Small uppercase labels, compact pills, and restrained accent buttons to preserve the clean agency tone.
Editorial spacing that lets each nested container breathe, with strong alignment and uncluttered copy blocks.

Tuning knobs

Nesting depth: choose how many layers of shells to use before the system feels too busy.
Contrast balance: tune the jump between the outer shell and inset containers so the hierarchy feels strong but elegant.
Corner radius: keep rounded containers polished and premium, but avoid making them feel overly playful.
Accent strength: use the accent color as punctuation for key controls, tags, and highlights only.
Container density: give cards enough internal padding so the system reads premium instead of cramped.

Avoid

Flat sections with no clear outer-to-inner container hierarchy.
Generic agency layouts that use one level of cards and call it structured.
Overdecorated gradients, glows, or excessive accent color that break the clean tone.
Equal visual weight on every nested block, which weakens hierarchy.
Cramped containers with insufficient spacing between shell levels.

Files

ATTRIBUTION.mdAdded by AutoGineer880 B
LICENSELicence file added by AutoGineer1.0 KiB
SKILL.md3.9 KiB
demo/PROMPT.md3.4 KiB
demo/assets/page-01-2f563338-39fa-47ea-9761-658d4f3f84db-1600w.jpg292.0 KiB
demo/assets/page-02-4f5668c5-fc4a-44e0-bc5e-a664189d3c31-1600w.jpg212.3 KiB
demo/assets/page-03-77415a2e-dcbc-4748-a29d-fced4821881a-1600w.jpg354.2 KiB
demo/assets/page-04-c92852bb-a510-405a-85ab-ffa0fde136a4-1600w.jpg209.1 KiB
demo/assets/source-preview.jpg72.1 KiB
demo/index.html21.4 KiB
demo/preview.jpg54.3 KiB
demo/source.json3.2 KiB

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>Squish — Turn Your Ideas Into Stunning Visuals</title>
<script src="../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"></script>
<script src="../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js"></script>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link href="https://fonts.googleapis.com/css2?family=Newsreader:wght@400;500&family=Inter:wght@300;400;500;600&family=Pacifico&display=swap" rel="stylesheet">
</head>
<body class="m-0 min-h-screen overflow-x-hidden bg-[#0a3bbf]" style="font-family:Inter,sans-serif;">

  <!-- Background WebGL canvas -->
  <canvas id="gl" class="fixed inset-0 w-full h-full -z-10" style="pointer-events:none;"></canvas>

  <!-- Dot grid overlay -->
  <div class="fixed inset-0 -z-10" style="pointer-events:none;background-image:radial-gradient(rgba(255,255,255,0.35) 1px, transparent 1px);background-size:26px 26px;opacity:0.18;"></div>

  <!-- Atmosphere gradient wash -->
  <div class="fixed inset-0 -z-10" style="pointer-events:none;background:linear-gradient(to bottom, rgba(150,170,210,0.15) 0%, rgba(40,90,220,0.05) 45%, rgba(20,55,180,0.55) 100%);"></div>

  <main class="relative min-h-screen flex flex-col" style="z-index:10;">

    <!-- Navigation -->
    <header class="w-full px-6 sm:px-10 lg:px-14 py-6 flex items-center justify-between">
      <a href="#" class="text-white text-3xl" style="font-family:Pacifico,cursive;letter-spacing:0.5px;">Squish</a>

      <nav class="hidden md:flex items-center gap-9 text-white">
        <a href="#" class="text-sm font-medium hover:opacity-80 transition-opacity duration-150">Product</a>
        <a href="#" class="text-sm font-medium hover:opacity-80 transition-opacity duration-150">Presets</a>
        <a href="#" class="text-sm font-medium hover:opacity-80 transition-opacity duration-150">Pricing</a>
        <a href="#" class="text-sm font-medium hover:opacity-80 transition-opacity duration-150">Blog</a>
        <a href="#" class="bg-white text-[#1a2440] text-sm font-semibold px-6 py-2.5 rounded-xl hover:scale-[1.03] transition-transform duration-150 shadow-[0px_2px_3px_-1px_rgba(0,0,0,0.1),0px_1px_0px_0px_rgba(25,28,33,0.02),0px_0px_0px_1px_rgba(25,28,33,0.08)]">Contact</a>
      </nav>

      <button id="menuBtn" class="md:hidden text-white" aria-label="Open menu">
        <iconify-icon icon="solar:hamburger-menu-linear" width="28" height="28"></iconify-icon>
      </button>
    </header>

    <!-- Mobile menu -->
    <div id="mobileMenu" class="md:hidden hidden px-6 pb-4 flex-col gap-3 text-white">
      <a href="#" class="text-sm font-medium py-1.5">Product</a>
      <a href="#" class="text-sm font-medium py-1.5">Presets</a>
      <a href="#" class="text-sm font-medium py-1.5">Pricing</a>
      <a href="#" class="text-sm font-medium py-1.5">Blog</a>
      <a href="#" class="bg-white text-[#1a2440] text-sm font-semibold px-6 py-2.5 rounded-xl text-center mt-1">Contact</a>
    </div>

    <!-- Hero -->
    <section class="flex-1 flex items-end">
      <div class="w-full px-6 sm:px-10 lg:px-14 pb-16 lg:pb-24 flex flex-col lg:flex-row lg:items-end lg:justify-between gap-10">

        <!-- Left copy -->
        <div class="max-w-2xl">
          <h1 class="text-white" style="font-family:Newsreader,serif;font-weight:400;letter-spacing:-0.025em;line-height:1.02;">
            <span class="block overflow-hidden">
              <span class="reveal-line block text-5xl sm:text-6xl lg:text-7xl">Turn Your Ideas Into</span>
            </span>
            <span class="block overflow-hidden mt-1">
              <span class="reveal-line block text-5xl sm:text-6xl lg:text-7xl">Stunning Visuals</span>
            </span>
          </h1>

          <p class="reveal-fade mt-7 text-white/90 text-base sm:text-lg max-w-md" style="font-weight:300;line-height:1.6;">
            An AI tool that turns prompts into quality images for branding and product design.
          </p>

          <a href="#" class="reveal-fade inline-flex items-center gap-2 mt-9 bg-white text-[#1a2440] text-base font-semibold px-7 py-4 rounded-2xl hover:scale-[1.03] transition-transform duration-150 shadow-[0px_2px_3px_-1px_rgba(0,0,0,0.1),0px_1px_0px_0px_rgba(25,28,33,0.02),0px_0px_0px_1px_rgba(25,28,33,0.08)]">
            Create your first image
          </a>
        </div>

        <!-- Right social proof -->
        <div class="reveal-fade flex flex-col items-start lg:items-end gap-2 text-white">
          <div class="flex items-center gap-1 text-yellow-300">
            <iconify-icon icon="solar:star-bold" width="16" height="16"></iconify-icon>
            <iconify-icon icon="solar:star-bold" width="16" height="16"></iconify-icon>
            <iconify-icon icon="solar:star-bold" width="16" height="16"></iconify-icon>
            <iconify-icon icon="solar:star-bold" width="16" height="16"></iconify-icon>
            <iconify-icon icon="solar:star-bold" width="16" height="16"></iconify-icon>
          </div>
          <p class="text-sm font-semibold">3k+ creators</p>
          <div class="flex -space-x-3 mt-1">
            <img src="assets/page-01-2f563338-39fa-47ea-9761-658d4f3f84db-1600w.jpg" class="w-9 h-9 rounded-full border-2 border-white object-cover" alt="Creator">
            <img src="assets/page-02-4f5668c5-fc4a-44e0-bc5e-a664189d3c31-1600w.jpg" class="w-9 h-9 rounded-full border-2 border-white object-cover" alt="Creator">
            <img src="assets/page-03-77415a2e-dcbc-4748-a29d-fced4821881a-1600w.jpg" class="w-9 h-9 rounded-full border-2 border-white object-cover" alt="Creator">
            <img src="assets/page-04-c92852bb-a510-405a-85ab-ffa0fde136a4-1600w.jpg" class="w-9 h-9 rounded-full border-2 border-white object-cover" alt="Creator">
          </div>
        </div>

      </div>
    </section>

  </main>

  <script>
    // Mobile menu toggle
    document.getElementById('menuBtn').addEventListener('click', function () {
      var m = document.getElementById('mobileMenu');
      m.classList.toggle('hidden');
      m.classList.toggle('flex');
    });

    // ---- Masked reveal animation ----
    window.addEventListener('load', function () {
      var lines = document.querySelectorAll('.reveal-line');
      lines.forEach(function (el, i) {
        el.style.transform = 'translateY(110%)';
        el.style.transition = 'transform 1s cubic-bezier(0.16,1,0.3,1)';
        el.style.transitionDelay = (0.15 + i * 0.12) + 's';
      });
      var fades = document.querySelectorAll('.reveal-fade');
      fades.forEach(function (el, i) {
        el.style.opacity = '0';
        el.style.transform = 'translateY(18px)';
        el.style.filter = 'blur(6px)';
        el.style.transition = 'opacity 0.9s ease, transform 0.9s ease, filter 0.9s ease';
        el.style.transitionDelay = (0.5 + i * 0.12) + 's';
      });
      requestAnimationFrame(function () {
        requestAnimationFrame(function () {
          lines.forEach(function (el) { el.style.transform = 'translateY(0%)'; });
          fades.forEach(function (el) {
            el.style.opacity = '1';
            el.style.transform = 'translateY(0)';
            el.style.filter = 'blur(0)';
          });
        });
      });
    });

    // ---- WebGL floral bloom background ----
    (function () {
      var canvas = document.getElementById('gl');
      var gl = canvas.getContext('webgl');
      if (!gl) return;

      var vs = 'attribute vec2 p;void main(){gl_Position=vec4(p,0.0,1.0);}';

      var fs = [
        'precision highp float;',
        'uniform vec2 u_res;',
        'uniform float u_time;',
        'uniform vec2 u_mouse;',
        'float hash(vec2 p){return fract(sin(dot(p,vec2(127.1,311.7)))*43758.5453);}',
        'float noise(vec2 p){vec2 i=floor(p);vec2 f=fract(p);f=f*f*(3.0-2.0*f);',
        ' float a=hash(i);float b=hash(i+vec2(1.0,0.0));float c=hash(i+vec2(0.0,1.0));float d=hash(i+vec2(1.0,1.0));',
        ' return mix(mix(a,b,f.x),mix(c,d,f.x),f.y);}',
        'float fbm(vec2 p){float v=0.0;float a=0.5;for(int i=0;i<5;i++){v+=a*noise(p);p*=2.0;a*=0.5;}return v;}',
        'void main(){',
        ' vec2 uv=gl_FragCoord.xy/u_res.xy;',
        ' vec2 st=uv;st.x*=u_res.x/u_res.y;',
        // base sky gradient: lighter top, deeper blue bottom
        ' vec3 top=vec3(0.62,0.70,0.86);',
        ' vec3 mid=vec3(0.30,0.52,0.92);',
        ' vec3 bot=vec3(0.05,0.23,0.72);',
        ' vec3 col=mix(top,mid,smoothstep(0.0,0.55,uv.y));',
        ' col=mix(bot,col,smoothstep(0.0,0.7,uv.y));',
        // flower center
        ' vec2 c=vec2(0.55,0.58);',
        ' c.x*=u_res.x/u_res.y;',
        ' vec2 d=st-c;',
        ' float ang=atan(d.y,d.x);',
        ' float rad=length(d);',
        // petal modulation
        ' float t=u_time*0.15;',
        ' float petals=0.5+0.5*sin(ang*7.0+sin(rad*6.0-t)*1.4);',
        ' float bloom=smoothstep(0.42,0.0,rad)*petals;',
        ' float warp=fbm(d*4.0+t*0.5)*0.6;',
        ' bloom+=smoothstep(0.30,0.0,rad)*warp;',
        // soft cloudy structure
        ' float cloud=fbm(d*3.0+vec2(t*0.3,t*0.2));',
        ' bloom*= (0.7+0.5*cloud);',
        // petal color: pink/purple outer, orange core
        ' vec3 petalA=vec3(0.78,0.55,0.92);',
        ' vec3 petalB=vec3(0.98,0.50,0.30);',
        ' vec3 core=vec3(1.0,0.62,0.25);',
        ' vec3 flower=mix(petalA,petalB,smoothstep(0.25,0.02,rad));',
        ' flower=mix(flower,core,smoothstep(0.10,0.0,rad));',
        ' col=mix(col,flower,clamp(bloom*1.3,0.0,0.92));',
        // subtle glow halo
        ' col+=vec3(0.5,0.45,0.6)*smoothstep(0.5,0.1,rad)*0.10;',
        // breathing pulse
        ' col*= (0.97+0.03*sin(u_time*0.6));',
        // mouse drift highlight
        ' float md=length(uv-u_mouse);',
        ' col+=vec3(0.2,0.25,0.4)*smoothstep(0.5,0.0,md)*0.05;',
        ' gl_FragColor=vec4(col,1.0);',
        '}'
      ].join('\n');

      function compile(type, src) {
        var s = gl.createShader(type);
        gl.shaderSource(s, src);
        gl.compileShader(s);
        return s;
      }
      var prog = gl.createProgram();
      gl.attachShader(prog, compile(gl.VERTEX_SHADER, vs));
      gl.attachShader(prog, compile(gl.FRAGMENT_SHADER, fs));
      gl.linkProgram(prog);
      gl.useProgram(prog);

      var buf = gl.createBuffer();
      gl.bindBuffer(gl.ARRAY_BUFFER, buf);
      gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1,-1,1,-1,-1,1,-1,1,1,-1,1,1]), gl.STATIC_DRAW);
      var loc = gl.getAttribLocation(prog, 'p');
      gl.enableVertexAttribArray(loc);
      gl.vertexAttribPointer(loc, 2, gl.FLOAT, false, 0, 0);

      var uRes = gl.getUniformLocation(prog, 'u_res');
      var uTime = gl.getUniformLocation(prog, 'u_time');
      var uMouse = gl.getUniformLocation(prog, 'u_mouse');

      var mouse = [0.55, 0.5], target = [0.55, 0.5];

      function resize() {
        var dpr = Math.min(window.devicePixelRatio || 1, 2);
        canvas.width = window.innerWidth * dpr;
        canvas.height = window.innerHeight * dpr;
        gl.viewport(0, 0, canvas.width, canvas.height);
      }
      window.addEventListener('resize', resize);
      resize();

      window.addEventListener('mousemove', function (e) {
        target[0] = e.clientX / window.innerWidth;
        target[1] = 1.0 - e.clientY / window.innerHeight;
      });

      var start = Date.now();
      function render() {
        mouse[0] += (target[0] - mouse[0]) * 0.04;
        mouse[1] += (target[1] - mouse[1]) * 0.04;
        gl.uniform2f(uRes, canvas.width, canvas.height);
        gl.uniform1f(uTime, (Date.now() - start) / 1000);
        gl.uniform2f(uMouse, mouse[0], mouse[1]);
        gl.drawArrays(gl.TRIANGLES, 0, 6);
        requestAnimationFrame(render);
      }
      render();
    })();
  </script>

</body>
</html>
";
    const assetFiles = ["assets/page-01-2f563338-39fa-47ea-9761-658d4f3f84db-1600w.jpg","assets/page-02-4f5668c5-fc4a-44e0-bc5e-a664189d3c31-1600w.jpg","assets/page-03-77415a2e-dcbc-4748-a29d-fced4821881a-1600w.jpg","assets/page-04-c92852bb-a510-405a-85ab-ffa0fde136a4-1600w.jpg"];
    const runtimeFiles = ["../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-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

Publisher

Meng To (Community)

Source

MengTo/Skills · agent-skills/web-design/nested-container-clean-agency · commit 5ea1661

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

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 nested-container-clean-agency.zip