AutoGineer
Generated banner for Orange Clean Paper Saas
Generated logo for Orange Clean Paper Saas

Orange Clean Paper Saas

Meng ToCommunityCreated by Meng To

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

From the author

Create a clean paper-toned SaaS design system with warm neutrals, orange accent signals, rounded premium forms, and polished product illustration surfaces.
— 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 design framework for building SaaS interfaces that prioritize a welcoming, premium feel over traditional cold, white-dashboard aesthetics. It focuses on using warm paper-toned surfaces, such as cream and parchment, paired with disciplined orange accents to create a modern, tactile, and product-led user experience. The guidelines cover surface treatment, typography, form design, and the integration of product illustrations to ensure a cohesive and elegant interface.

What it does

  • Defines a warm color palette using off-white, cream, and parchment surfaces.
  • Establishes orange as a strategic signal color for buttons, active states, and emphasis.
  • Provides patterns for high-quality, rounded forms and layered UI components.
  • Offers guidance on integrating polished product illustrations and floating UI elements.
  • Sets standards for typography and motion to maintain a professional SaaS tone.
  • Outlines specific tuning knobs to balance warmth, energy, and visual richness.

When to use it

  • When designing a SaaS onboarding flow that needs to feel approachable and premium.
  • When moving away from standard, cold blue-gray or stark white dashboard designs.
  • When you need a cohesive visual language for product mockups and UI shells.
  • When creating interfaces that require a balance between functional forms and visual storytelling.

Advantages

  • Creates a distinct, memorable brand identity that feels more human and less technical.
  • Improves user perception of quality through tactile, layered surface treatments.
  • Maintains focus on usability by using color as a disciplined signal rather than decoration.
  • Provides a clear, actionable framework for consistent UI design across a product.

Usage examples

“Apply the orange-clean-paper-saas design system to my new onboarding flow.”
The agent will generate a layout featuring warm parchment backgrounds, rounded input forms with orange focus rings, and a side-by-side product illustration panel.
“How should I style my primary CTA buttons using the paper-toned SaaS guidelines?”
The agent will recommend using a clean, orange-accented button style that maintains high contrast against the warm background while adhering to the system's rounded aesthetic.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/mengto/orange-clean-paper-saas/download

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

    mkdir -p .agents/skills && unzip orange-clean-paper-saas.zip -d .agents/skills

Documentation by Meng To

Orange Clean Paper SaaS Skill

Use When

  • Create a clean paper-toned SaaS design system with warm neutrals, orange accent signals, rounded premium forms, and polished product illustration surfaces.

Workflow

Scope

  • Apply this as a full design-system direction across page shell, forms, product mockups, cards, CTAs, illustration zones, and motion.

  • Use it when the interface should feel like a refined SaaS onboarding or product experience built on warm paper tones rather than cold white dashboards.

  • This is not generic startup UI and not a purely technical paper system. It should feel welcoming, polished, and product-led while staying premium.

Visual target

  • Build the interface with warm off-white, cream, parchment, and pale stone surfaces instead of stark white.

  • Use orange as the primary signal and action color for steps, buttons, active states, icons, focused inputs, and small emphasis details.

  • Keep the overall system clean and modern, with generous radius, soft shadows, and carefully layered surfaces that feel tactile but not skeuomorphic.

  • Pair a functional form or onboarding area with a polished visual product panel, such as illustrated cards, floating stats, or a dimensional app object.

  • Let the mood feel calm and premium, with orange used as a warm energetic accent rather than a loud marketing blast.

Implementation guidance

  • Prefer a large rounded master container with subtle gradient-border treatment and a warm background shell around the main UI.

  • Build forms with high-quality light inputs: paper-toned fill, delicate borders, subtle focus rings, and soft hover states tied to the orange accent.

  • Use orange in a disciplined way for step markers, primary CTAs, highlight icons, link text, micro-badges, and small progress indicators.

  • Create a companion product-illustration region using warm gradients, floating cards, soft glassy white UI panels, or rendered product objects to communicate the platform visually.

  • Use clean sans-serif typography, light-to-regular weight body copy, and restrained hierarchy so the experience feels elegant and approachable.

  • Motion should stay polished and product-grade: masked text reveals, gentle floating elements, smooth input focus transitions, and calm ambient movement in the illustration zone.

Recommended patterns

  • Split onboarding card with a form panel on one side and a visual product demonstration panel on the other.

  • Warm paper surfaces layered inside a slightly brighter or softer radial page background.

  • Rounded white or cream cards with light gradient borders and soft orange-tinted shadows.

  • Floating UI chips, balance cards, card objects, or product visuals that add depth without clutter.

  • Orange primary button paired with quiet secondary actions and neutral dividers to preserve the clean SaaS tone.

Tuning knobs

  • Paper warmth: shift between cooler cream and richer parchment depending on the brand feel.

  • Orange energy: keep the accent vivid enough to feel active, but restrained enough that the interface remains calm.

  • Radius and softness: use generous rounding and shadow lift, but avoid turning the system into bubbly consumer UI.

  • Visual richness: add or reduce floating product elements depending on how illustration-heavy the page should be.

  • Contrast: preserve clear readability between warm backgrounds, white cards, gray copy, and orange actions.

Avoid

  • Cold blue-gray SaaS UI that ignores the warm paper character.

  • Flat white forms with no softness, product depth, or premium surface treatment.

  • Oversaturating the whole page with orange instead of using it as a signal color.

  • Heavy vintage paper distressing that makes the SaaS product feel old-fashioned.

  • Overcomplicated illustrations or noisy 3D objects that distract from the clean onboarding experience.

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="antialiased">
<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>PaperFlow Design Layout</title>
    <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap">
    <script src="../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"></script>
    <script src="../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js"></script>
    <!-- GSAP for animations and ScrollTrigger reveal -->
    <script src="../../../../assets/runtime/runtime-027051effa47-gsap-min.js"></script>
    <script src="../../../../assets/runtime/runtime-689ca8dda44c-scrolltrigger-min.js"></script>
</head>
<body class="min-h-screen flex items-center justify-center p-4 md:p-8 lg:p-12 text-stone-800" style="font-family: 'Inter', sans-serif; background-color: #EFECE5; background-image: radial-gradient(circle at 50% 0%, #F8F5EF 0%, transparent 70%);">

    <!-- Main Outer Container mimicking the image frame -->
    <main class="w-full max-w-[1280px] bg-gradient-to-b from-[#FCFAF6]/90 to-[#F5F2EA]/90 backdrop-blur-3xl rounded-[2.5rem] shadow-[0_8px_40px_rgba(230,92,0,0.03),0_1px_3px_rgba(0,0,0,0.02)] p-4 md:p-6 lg:p-8 ring-1 ring-white/60">
        
        <!-- Grid Layout -->
        <div class="grid grid-cols-12 gap-4 lg:gap-5">

            <!-- Card 1: UI Stack -->
            <div class="col-span-12 lg:col-span-3 lg:row-span-2 bg-gradient-to-b from-[#FDFBF7] to-[#F7F4EB] rounded-2xl overflow-hidden relative flex flex-col group transition-all duration-300 hover:shadow-lg shadow-sm ring-1 ring-stone-200/50" style="box-shadow: inset 0 1px 0 rgba(255,255,255,0.8), 0 4px 20px rgba(0,0,0,0.02);">
                <div class="flex-1 bg-gradient-to-br from-[#F5EFE6] to-[#FCE8D5] p-6 relative overflow-hidden">
                    <!-- Nav fake -->
                    <div class="flex items-center justify-between mb-8 relative z-10">
                        <div class="flex items-center gap-2">
                            <div class="w-4 h-4 rounded-full bg-[#E65C00]"></div>
                            <span class="text-xs font-medium tracking-tight text-stone-800">Flow</span>
                        </div>
                        <div class="flex gap-3 text-xs text-stone-500 font-medium">
                            <span class="hover:text-stone-800 cursor-pointer transition-colors">Platform</span>
                            <span class="hover:text-stone-800 cursor-pointer transition-colors">Plans</span>
                        </div>
                    </div>
                    <!-- Content -->
                    <div class="relative z-10 max-w-[85%]">
                        <h2 class="gsap-reveal text-2xl font-medium tracking-tight leading-tight mb-2 text-stone-900">Streamline operations with smart workflows.</h2>
                        <p class="text-xs text-stone-500 mb-6">Optimize your daily tasks and harness data for clear outcomes.</p>
                        <button class="bg-[#E65C00] text-white text-xs px-4 py-1.5 rounded-full font-medium hover:bg-[#CC5200] transition-all shadow-[0_2px_10px_rgba(230,92,0,0.2)] hover:shadow-[0_4px_14px_rgba(230,92,0,0.3)]">Get Started</button>
                    </div>
                    
                    <!-- Abstract UI elements -->
                    <div class="absolute -bottom-12 -right-12 w-48 h-48 rounded-full border-[16px] border-[#F2DECE] opacity-90 group-hover:scale-105 transition-transform duration-500"></div>
                    <div class="absolute -top-12 -right-4 w-32 h-32 rounded-full border-[12px] border-white/40 opacity-90 group-hover:scale-105 transition-transform duration-500 delay-75"></div>
                </div>
                
                <!-- Bottom section of stacked card -->
                <div class="h-32 bg-gradient-to-tr from-[#F4EBE1] to-[#FCEEE3] relative border-t border-white/40 p-6 flex flex-col justify-end overflow-hidden">
                    <div class="absolute bottom-0 right-0 w-32 h-32 bg-[#E65C00] rounded-tl-full opacity-30 blur-2xl translate-x-1/2 translate-y-1/2"></div>
                    <span class="gsap-reveal text-lg font-medium tracking-tight relative z-10 text-stone-800">Expand capabilities.</span>
                </div>
            </div>

            <!-- Card 2: Intro -->
            <div class="col-span-12 md:col-span-6 lg:col-span-3 bg-gradient-to-b from-[#FDFBF7] to-[#F7F4EB] rounded-2xl overflow-hidden relative p-6 flex flex-col justify-between min-h-[220px] shadow-sm ring-1 ring-stone-200/50" style="box-shadow: inset 0 1px 0 rgba(255,255,255,0.8), 0 4px 20px rgba(0,0,0,0.02);">
                <div class="absolute inset-0 bg-gradient-to-br from-[#FFF8EE] via-[#FDFBF7] to-[#FDF4E9] opacity-80"></div>
                <!-- Moving gradient blob -->
                <div class="gsap-blob absolute -top-20 -left-20 w-64 h-64 bg-gradient-to-r from-[#FFB380] to-[#FFD6AD] rounded-full mix-blend-multiply filter blur-[40px] opacity-40"></div>
                
                <div class="flex justify-between items-start text-xs font-medium text-stone-500 relative z-10 mb-8">
                    <span>@jordanhayes</span>
                    <div class="flex gap-3">
                        <span class="hover:text-stone-800 cursor-pointer transition-colors">Projects</span>
                        <span class="hover:text-stone-800 cursor-pointer transition-colors">About</span>
                    </div>
                </div>
                <div class="relative z-10">
                    <p class="gsap-reveal text-lg font-normal tracking-tight leading-snug text-stone-700">I'm <span class="font-medium text-stone-900">Jordan Hayes</span>,<br>a product engineer crafting<br>tools in London.</p>
                </div>
                <div class="flex justify-between items-end text-xs text-stone-400 mt-6 relative z-10">
                    <span class="flex items-center gap-1.5"><span class="w-1.5 h-1.5 rounded-full bg-[#E65C00]"></span> Open to roles</span>
                    <div class="flex gap-2">
                        <span class="hover:text-[#E65C00] cursor-pointer transition-colors">Github</span>
                        <span class="hover:text-[#E65C00] cursor-pointer transition-colors">X</span>
                    </div>
                </div>
            </div>

            <!-- Card 3: 3D Box placeholder -->
            <div class="col-span-12 md:col-span-6 lg:col-span-2 bg-[#F5F2EA] rounded-2xl overflow-hidden relative min-h-[220px] flex items-center justify-center group cursor-pointer shadow-inner ring-1 ring-stone-200/50">
                <!-- Faux 3D / Abstract composition -->
                <div class="gsap-float relative w-full h-full flex items-center justify-center">
                    <div class="absolute w-20 h-28 bg-[#FDFBF7] border border-stone-200/80 rounded-lg shadow-[0_8px_20px_rgba(230,92,0,0.05)] translate-x-4 translate-y-4 rotate-6 z-10 transition-transform duration-500 ease-out group-hover:rotate-12 group-hover:translate-x-6 group-hover:-translate-y-2">
                        <div class="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 w-8 h-8 bg-gradient-to-tr from-[#E65C00] to-[#FFB380] rounded-full blur-md opacity-40"></div>
                    </div>
                    <div class="absolute w-16 h-24 bg-[#FAF7F0] border border-stone-200/60 rounded-lg shadow-sm -translate-x-6 -translate-y-2 -rotate-3 z-0 transition-transform duration-500 ease-out group-hover:-rotate-6 group-hover:-translate-x-8 group-hover:translate-y-2">
                        <div class="absolute top-1/4 left-1/4 w-6 h-6 bg-gradient-to-tr from-stone-300 to-stone-200 rounded-full blur-sm opacity-60"></div>
                    </div>
                </div>
            </div>

            <!-- Card 4: Hero Gradient -->
            <div class="col-span-12 lg:col-span-4 lg:row-span-2 bg-gradient-to-b from-[#FDFBF7] to-[#F7F4EB] rounded-2xl overflow-hidden relative p-8 flex flex-col justify-between min-h-[460px] shadow-sm ring-1 ring-stone-200/50" style="box-shadow: inset 0 1px 0 rgba(255,255,255,0.8), 0 4px 20px rgba(0,0,0,0.02);">
                <!-- Top Nav -->
                <div class="flex justify-between items-center text-xs font-medium text-stone-500 relative z-20">
                    <div class="flex items-center gap-1.5 text-stone-800">
                        <iconify-icon icon="solar:layers-linear" width="16" height="16" style="stroke-width: 1.5;"></iconify-icon>
                        <span>Ecosystem</span>
                    </div>
                    <div class="flex gap-4">
                        <span class="hidden sm:inline hover:text-stone-800 cursor-pointer transition-colors">Blocks</span>
                        <span class="hidden sm:inline hover:text-stone-800 cursor-pointer transition-colors">Themes</span>
                        <span class="text-[#E65C00]">Upgrade</span>
                    </div>
                </div>

                <!-- WebGL simulated blob -->
                <div class="absolute inset-0 z-0 overflow-hidden pointer-events-none">
                    <div class="gsap-blob absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 w-[120%] h-[120%] bg-[radial-gradient(circle_at_center,_var(--tw-gradient-stops))] from-[#FFD6AD] via-[#FCE8D5] to-transparent opacity-40 mix-blend-multiply blur-[60px]"></div>
                    <div class="gsap-blob-reverse absolute top-1/4 left-1/4 w-[80%] h-[80%] bg-[radial-gradient(circle_at_center,_var(--tw-gradient-stops))] from-[#E65C00] via-[#FFB380] to-transparent opacity-10 mix-blend-color-burn blur-[50px]"></div>
                </div>

                <!-- Main Content -->
                <div class="relative z-10 flex flex-col items-center text-center mt-12 mb-8">
                    <h1 class="gsap-reveal text-4xl sm:text-5xl font-medium tracking-tight leading-[1.1] text-stone-900 mb-4 max-w-[280px]">
                        Refined product assets
                    </h1>
                    <p class="text-xs text-stone-500 mb-6 max-w-[220px]">Subscribe to get exclusive platform components delivered weekly.</p>
                    
                    <div class="flex w-full max-w-[280px] bg-[#FDFBF7] rounded-full border border-stone-200 p-1 shadow-[0_2px_8px_rgba(0,0,0,0.02)] transition-all duration-300 focus-within:border-[#E65C00]/50 focus-within:ring-2 focus-within:ring-[#E65C00]/10 focus-within:shadow-md hover:border-stone-300">
                        <input type="email" placeholder="Email address" class="flex-1 bg-transparent px-4 text-sm outline-none placeholder:text-stone-400 font-medium text-stone-800">
                        <button class="bg-[#E65C00] text-white text-xs px-4 py-2 rounded-full font-medium hover:bg-[#CC5200] transition-colors flex items-center gap-1 shadow-[0_2px_8px_rgba(230,92,0,0.25)]">
                            Subscribe <iconify-icon icon="solar:arrow-right-linear" width="14" height="14" style="stroke-width: 1.5;"></iconify-icon>
                        </button>
                    </div>
                </div>

                <!-- Bottom Footer -->
                <div class="relative z-10 flex justify-between items-end text-[10px] text-stone-400 uppercase tracking-wider mt-auto pt-8 border-t border-stone-200/60">
                    <div>
                        <span class="block mb-1">Latest Drop</span>
                        <span class="text-stone-800 font-medium normal-case tracking-normal text-xs">Tactile UI Kit</span>
                    </div>
                    <div class="text-right">
                        <span class="block mb-1">Published</span>
                        <span class="text-stone-800 font-medium normal-case tracking-normal text-xs">Nov 12, 2023</span>
                    </div>
                </div>
            </div>

            <!-- Card 5: Core Text -->
            <div class="col-span-12 md:col-span-6 lg:col-span-3 bg-gradient-to-b from-[#FDFBF7] to-[#F7F4EB] rounded-2xl p-6 flex flex-col justify-between shadow-sm ring-1 ring-stone-200/50" style="box-shadow: inset 0 1px 0 rgba(255,255,255,0.8), 0 4px 20px rgba(0,0,0,0.02);">
                <div class="flex justify-between items-start text-xs text-stone-400 mb-8">
                    <span class="uppercase tracking-wider text-[10px]">Pillar</span>
                    <span class="font-medium text-[#E65C00]">01</span>
                </div>
                <div>
                    <h3 class="gsap-reveal text-xl font-medium tracking-tight mb-2 text-stone-900">Frameworks.</h3>
                    <p class="text-sm text-stone-500 font-normal leading-relaxed">Robust interface frameworks, dynamic components, and polished applications designed for modern scale.</p>
                </div>
            </div>

            <!-- Card 6: Typography -->
            <div class="col-span-12 md:col-span-6 lg:col-span-2 bg-gradient-to-b from-[#FDFBF7] to-[#F7F4EB] rounded-2xl p-6 flex flex-col justify-center items-center relative overflow-hidden group shadow-sm ring-1 ring-stone-200/50" style="box-shadow: inset 0 1px 0 rgba(255,255,255,0.8), 0 4px 20px rgba(0,0,0,0.02);">
                <div class="absolute inset-0 bg-stone-100/50 opacity-0 group-hover:opacity-100 transition-opacity duration-500"></div>
                <h3 class="gsap-reveal text-3xl font-medium tracking-tight text-stone-900 relative z-10 leading-none text-center">Inter<br>Sans</h3>
                
                <div class="w-full flex justify-between mt-8 text-[10px] text-stone-400 uppercase tracking-wider relative z-10 border-t border-stone-200/60 pt-3">
                    <div class="flex flex-col"><span>Weights</span><span class="text-stone-800 font-medium normal-case text-xs">9</span></div>
                    <div class="flex flex-col text-right"><span>Category</span><span class="text-stone-800 font-medium normal-case text-xs">Neo</span></div>
                </div>
            </div>

            <!-- Card 7: Palette -->
            <div class="col-span-12 md:col-span-6 lg:col-span-3 bg-gradient-to-b from-[#FDFBF7] to-[#F7F4EB] rounded-2xl overflow-hidden flex flex-col h-40 shadow-sm ring-1 ring-stone-200/50 p-1" style="box-shadow: inset 0 1px 0 rgba(255,255,255,0.8), 0 4px 20px rgba(0,0,0,0.02);">
                <div class="flex-1 bg-[#FDFBF7] rounded-t-xl p-3 flex items-start border-b border-stone-100">
                    <span class="text-[10px] font-medium text-stone-500 tracking-wider uppercase">Base Light</span>
                </div>
                <div class="flex-1 bg-[#EFECE5] border-b border-stone-200/50"></div>
                <div class="flex-1 bg-[#FFB380] border-b border-orange-200/50"></div>
                <div class="flex-1 bg-[#E65C00] rounded-b-xl flex items-end justify-end p-2">
                    <span class="text-[10px] font-medium text-white/80 tracking-wider uppercase">Action</span>
                </div>
            </div>

            <!-- Card 8: Discover -->
            <div class="col-span-12 lg:col-span-5 bg-gradient-to-b from-[#FDFBF7] to-[#F7F4EB] rounded-2xl p-8 flex flex-col items-center justify-center text-center shadow-sm ring-1 ring-stone-200/50" style="box-shadow: inset 0 1px 0 rgba(255,255,255,0.8), 0 4px 20px rgba(0,0,0,0.02);">
                <div class="flex items-center gap-2 mb-6">
                    <div class="w-8 h-8 rounded-full bg-[#FFF5E6] flex items-center justify-center text-[#E65C00] shadow-[inset_0_1px_2px_rgba(255,255,255,0.8)] ring-1 ring-[#E65C00]/10">
                        <iconify-icon icon="solar:compass-square-linear" width="18" height="18" style="stroke-width: 1.5;"></iconify-icon>
                    </div>
                    <span class="text-xs font-medium tracking-tight text-stone-600">Collection</span>
                </div>
                <h2 class="gsap-reveal text-2xl sm:text-3xl font-medium tracking-tight mb-3 text-stone-900">Discover crafted interface patterns.</h2>
                <p class="text-sm text-stone-500 mb-6 max-w-md">Showcasing hundreds of premium interactions and tailored layouts for SaaS applications.</p>
                <button class="bg-white text-stone-800 text-xs px-5 py-2.5 rounded-full font-medium hover:text-[#E65C00] transition-colors flex items-center gap-2 shadow-[0_2px_10px_rgba(0,0,0,0.04),inset_0_1px_0_rgba(255,255,255,1)] ring-1 ring-stone-200">
                    Explore Gallery <iconify-icon icon="solar:arrow-right-up-linear" width="14" height="14" style="stroke-width: 1.5;"></iconify-icon>
                </button>
            </div>

            <!-- Card 9: Logo -->
            <div class="col-span-12 lg:col-span-4 bg-gradient-to-b from-[#FDFBF7] to-[#F7F4EB] rounded-2xl p-8 flex items-center justify-center group cursor-pointer shadow-sm ring-1 ring-stone-200/50" style="box-shadow: inset 0 1px 0 rgba(255,255,255,0.8), 0 4px 20px rgba(0,0,0,0.02);">
                <div class="flex items-center gap-3 transition-transform duration-500 ease-out group-hover:scale-105">
                    <div class="w-10 h-10 rounded-xl bg-gradient-to-br from-[#E65C00] to-[#FF8C40] flex items-center justify-center text-white shadow-[0_4px_12px_rgba(230,92,0,0.3)]">
                        <iconify-icon icon="solar:leaf-linear" width="22" height="22" style="stroke-width: 1.5;"></iconify-icon>
                    </div>
                    <span class="text-2xl font-medium tracking-tighter text-stone-900">PaperFlow</span>
                </div>
            </div>

        </div>
    </main>

    <script>
        document.addEventListener('DOMContentLoaded', () => {
            gsap.registerPlugin(ScrollTrigger);

            // Masked Staggered Word Reveal
            document.querySelectorAll('.gsap-reveal').forEach(el => {
                const text = el.innerText;
                el.innerHTML = '';
                const words = text.split(' ');
                
                words.forEach((word, i) => {
                    const wordWrap = document.createElement('span');
                    wordWrap.style.display = 'inline-block';
                    wordWrap.style.overflow = 'hidden';
                    wordWrap.style.verticalAlign = 'bottom';
                    wordWrap.style.paddingRight = i < words.length - 1 ? '0.25em' : '0';
                    
                    const wordInner = document.createElement('span');
                    wordInner.style.display = 'inline-block';
                    wordInner.style.transform = 'translateY(110%)';
                    wordInner.style.transformOrigin = 'top left';
                    wordInner.innerText = word;
                    wordInner.className = 'reveal-word';
                    
                    wordWrap.appendChild(wordInner);
                    el.appendChild(wordWrap);
                });

                gsap.to(el.querySelectorAll('.reveal-word'), {
                    y: '0%',
                    ease: 'power3.out',
                    duration: 0.9,
                    stagger: 0.04,
                    scrollTrigger: {
                        trigger: el,
                        start: 'top 95%',
                        toggleActions: 'play none none none'
                    }
                });
            });

            // Ambient Blob Animations
            gsap.to('.gsap-blob', {
                rotation: 360,
                scale: 1.15,
                x: 20,
                y: -20,
                duration: 25,
                repeat: -1,
                yoyo: true,
                ease: 'sine.inOut'
            });

            gsap.to('.gsap-blob-reverse', {
                rotation: -360,
                scale: 1.2,
                x: -30,
                y: 20,
                duration: 30,
                repeat: -1,
                yoyo: true,
                ease: 'sine.inOut'
            });

            // Gentle Float Animation
            gsap.to('.gsap-float > div', {
                y: -8,
                duration: 4,
                repeat: -1,
                yoyo: true,
                ease: 'sine.inOut',
                stagger: {
                    each: 1,
                    from: "start"
                }
            });
        });
    </script>
</body>
</html>
";
    const assetFiles = [];
    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/orange-clean-paper-saas · 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 orange-clean-paper-saas.zip