AutoGineer
Generated banner for Light Mode Paper Technical
Generated logo for Light Mode Paper Technical

Light Mode Paper Technical

Meng ToCommunityCreated by Meng To

  • Skill
  • Content generator
  • Design and creative
  • MIT
  • Medium risk
Download ZIP

From the author

Create a light-mode technical design system with warm paper surfaces, dark outer framing, subtle diagonal texture, precise bracketed geometry, and restrained accent signals.
— the description by Meng To

AutoGineer summary

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

This skill provides a comprehensive visual language for building light-mode interfaces that balance tactile warmth with technical precision. It moves away from standard, cold enterprise dashboards by utilizing parchment-toned surfaces, subtle diagonal textures, and structured framing elements like L-brackets and inset rules. The system emphasizes a premium, intentional aesthetic where a light, paper-like interior is nested within a darker outer shell, creating a refined and highly readable environment suitable for modern technical applications.

What it does

  • Defines a color palette centered on warm neutrals and parchment tones.
  • Provides structural patterns for framing content with inset rules and corner brackets.
  • Suggests techniques for adding subtle, non-distracting diagonal textures to backgrounds.
  • Outlines a typography strategy using clean sans-serifs paired with mono utility text.
  • Establishes rules for restrained accent usage to highlight active states and focal points.
  • Offers guidance on motion design to ensure a calm and polished user experience.

When to use it

  • When designing a technical interface that needs to feel more welcoming than standard white-on-gray UI.
  • When you want to blend the tactile quality of paper with the precision of a technical dashboard.
  • When building app mockups, transcript panes, or sidebars that require a premium, contemporary look.
  • When you need to establish a clear hierarchy through layered framing and material contrast.

Advantages

  • Creates a unique, high-end aesthetic that stands out from generic SaaS designs.
  • Improves readability through the use of warm, eye-friendly surface tones.
  • Provides a clear, modular framework for organizing complex technical information.
  • Maintains a professional, instrumented feel without sacrificing user comfort.
  • Offers flexible tuning knobs to adjust warmth, framing strength, and texture density.

Usage examples

“Apply the light-mode paper technical style to a new dashboard layout.”
The agent will generate a layout featuring a dark outer field, a warm paper-toned central container, and precise geometric framing elements.
“How should I style the transcript window for my technical app?”
The agent will recommend using a clean, light interior with subtle border hierarchy and mono-spaced typography for metadata.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/mengto/light-mode-paper-technical/download

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

    mkdir -p .agents/skills && unzip light-mode-paper-technical.zip -d .agents/skills

Documentation by Meng To

Light Mode Paper Technical Skill

Use When

  • Create a light-mode technical design system with warm paper surfaces, dark outer framing, subtle diagonal texture, precise bracketed geometry, and restrained accent signals.

Workflow

Scope

  • Apply this as a full design-system direction across shell, layout, typography, navigation, cards, mockups, background treatment, and motion.

  • Use it when the interface should feel bright, refined, and technical, but warmer and more tactile than a cold white enterprise dashboard.

  • This is not plain minimal light mode and not editorial paper alone. It should combine paper-like surfaces with precise product-tech framing.

Visual target

  • Build the main experience on warm off-white, parchment, or soft paper-toned surfaces instead of stark white.

  • Wrap the lighter interior inside a darker outer shell or surrounding field so the content area feels framed, elevated, and intentional.

  • Add subtle technical structure: thin borders, inset rules, L-brackets, tiny corner details, diagonal background texture, and measured spatial guides.

  • Use one restrained accent color for active states, labels, progress, or focal details. The accent should punctuate the system rather than dominate it.

  • Keep the overall result premium and contemporary: rounded container shells are acceptable, but internal layout logic should remain crisp and technical.

Implementation guidance

  • Prefer a framed master container with generous radius, soft shadow, and a light paper interior placed against a darker page background.

  • Use warm neutrals for primary surfaces, then separate layers with slightly darker paper tones, soft borders, and gentle contrast instead of bright white-on-gray UI.

  • Add low-contrast diagonal texture or fine patterning to large paper regions so the background feels material and lightly engineered.

  • Use clean sans-serif typography for interface content and optional mono utility text for timestamps, captions, browser chrome, transcript cues, or metadata.

  • Build product surfaces such as app mockups, transcript panes, sidebars, or session cards with bright clean interiors, careful spacing, and delicate border hierarchy.

  • Motion should stay calm and polished: masked headline reveals, fade-up sections, controlled card entrance, and subtle activity indicators are appropriate.

Recommended patterns

  • Dark outer page with a large light rounded container holding the whole experience.

  • Inner framing system using inset border rectangles, small corner brackets, and quiet technical lines over paper-toned backgrounds.

  • Warm light app panels with browser chrome, transcript windows, sidebars, or dashboard modules nested inside the main shell.

  • Accent-driven live states such as active bullets, tiny dividers, progress marks, highlighted words, or primary call-to-action buttons.

  • Paper-technical contrast: soft, readable, welcoming surfaces paired with precise geometry and system-level visual discipline.

Tuning knobs

  • Paper warmth: shift between cooler stone paper and warmer parchment depending on the brand mood.

  • Framing strength: add or reduce brackets, boundary lines, and technical rules depending on how instrumented the design should feel.

  • Roundness: keep outer shells softly rounded, but avoid over-softening inner layout structures.

  • Accent intensity: keep the accent crisp and memorable, but let warm neutrals carry most of the interface.

  • Texture amount: maintain subtle patterning so the paper feel reads without becoming noisy or vintage.

Avoid

  • Flat plain white SaaS layouts with no material warmth or framing logic.

  • Heavy vintage paper distressing that makes the interface feel old or dirty.

  • Cold enterprise blue-gray systems that lose the soft paper character.

  • Overusing rounded blobs or generic consumer-app softness that fights the technical structure.

  • Excessive accent usage that turns the paper system into a loud marketing palette.

Files

demo/index.html

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

<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>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
Meng To
Publisher
Meng To (Community)
Source
MengTo/Skills · agent-skills/web-design/light-mode-paper-technical · 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 light-mode-paper-technical.zip