More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Cinematic Landing Page Engine

    1

    Generates scroll-driven cinematic landing pages — full React or vanilla code, not just design specs.

    $29

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Cinematic Landing Page Engine

    Cinematic Landing Page Engine

    Example session with this skill installed

    Build me a cinematic landing page for Notely, an AI meeting-notes app
    launching its waitlist. Tone: restrained/luxury, like an Apple product
    page. Stack: React + Tailwind + Framer Motion. Sections: hero, one-line
    value prop, 3 features, social proof logos, final CTA.

    • Read your context and instructions
    • Compiled the cinematic landing page
    • Generated the app files

    I built NotelyLanding.jsx using the cinematic beat structure: cold open →
    establishing statement → 3 staggered feature reveals → understated proof
    beat → climax CTA. Tone is restrained/luxury — expo-out easing
    (cubic-bezier(0.16, 1, 0.3, 1)), 0.6–1.4s durations, 5–10% background
    parallax drift on the hero. Every animated element ships a
    prefers-reduced-motion fallback via useReducedMotion(), and the parallax
    transform is scoped to desktop only.

    import { motion, useReducedMotion, useScroll, useTransform } from "framer-motion";
    import { useRef } from "react";
    
    const EASE = [0.16, 1, 0.3, 1]; // restrained/luxury signature curve
    
    function Reveal({ children, delay = 0, y = 24, className = "" }) {
      const reduceMotion = useReducedMotion();
      return (
        <motion.div
          className={className}
          initial={reduceMotion ? false : { opacity: 0, y }}
          whileInView={{ opacity: 1, y: 0 }}
          viewport={{ once: true, amount: 0.2 }}
          transition={{ duration: 0.7, ease: EASE, delay }}
        >
          {children}
        </motion.div>
      );
    }
    
    function ParallaxHero({ children }) {
      const ref = useRef(null);
      const { scrollYProgress } = useScroll({ target: ref, offset: ["start start", "end start"] });
      const y = useTransform(scrollYProgress, [0, 1], [0, 120]);
      const opacity = useTransform(scrollYProgress, [0, 0.8], [1, 0]);
    
      return (
        <section ref={ref} className="relative h-screen overflow-hidden bg-[#0A0A0B]">
          <motion.div style={{ y }} className="absolute inset-0 -z-10 bg-gradient-to-b from-[#141416] to-[#0A0A0B]" />
          <motion.div style={{ opacity }} className="relative z-10 flex h-full items-center justify-center">
            {children}
          </motion.div>
        </section>
      );
    }
    
    function TextReveal({ text, className = "" }) {
      const words = text.split(" ");
      return (
        <motion.h1
          className={className}
          initial="hidden"
          whileInView="show"
          viewport={{ once: true, amount: 0.5 }}
          variants={{ show: { transition: { staggerChildren: 0.05 } } }}
        >
          {words.map((word, i) => (
            <motion.span
              key={i}
              className="inline-block mr-[0.25em]"
              variants={{ hidden: { opacity: 0, y: 16 }, show: { opacity: 1, y: 0 } }}
              transition={{ duration: 0.5, ease: EASE }}
            >
              {word}
            </motion.span>
          ))}
        </motion.h1>
      );
    }
    
    const container = {
      hidden: {},
      show: { transition: { staggerChildren: 0.09 } },
    };
    const item = {
      hidden: { opacity: 0, y: 20 },
      show: { opacity: 1, y: 0, transition: { duration: 0.6, ease: EASE } },
    };
    
    function StaggerGroup({ children, className = "" }) {
      const reduceMotion = useReducedMotion();
      return (
        <motion.div
          className={className}
          variants={reduceMotion ? undefined : container}
          initial={reduceMotion ? false : "hidden"}
          whileInView={reduceMotion ? undefined : "show"}
          viewport={{ once: true, amount: 0.2 }}
        >
          {children}
        </motion.div>
      );
    }
    
    export default function NotelyLanding() {
      return (
        <main className="bg-[#FAFAF8] text-[#0A0A0B]">
          {/* Cold open */}
          <ParallaxHero>
            <div className="text-center px-6">
              <TextReveal
                text="Notely remembers so you don't have to."
                className="text-white text-5xl md:text-7xl font-medium tracking-tight"
              />
              <Reveal delay={0.9}>
                <button className="mt-10 px-8 py-3 rounded-full bg-white text-[#0A0A0B] text-sm tracking-wide">
                  Join the waitlist
                </button>
              </Reveal>
            </div>
          </ParallaxHero>
    
      {/* Establishing beat */}
    
          <section className="py-40 max-w-2xl mx-auto px-6 text-center">
            <Reveal>
              <p className="text-2xl md:text-3xl leading-relaxed text-[#1a1a1a]">
    
            Every meeting, every idea, every follow-up — captured automatically,
            organized without a single tag.
    
              </p>
            </Reveal>
          </section>
    
      {/* Rising beats */}
    
          <StaggerGroup className="py-32 grid md:grid-cols-3 gap-12 max-w-5xl mx-auto px-6">
            {[
              { title: "Listens", body: "Transcribes every meeting in the background." },
              { title: "Connects", body: "Links related notes across weeks automatically." },
              { title: "Surfaces", body: "Resurfaces the right note exactly when you need it." },
            ].map((f) => (
              <motion.div key={f.title} variants={item}>
                <h3 className="text-xl font-medium mb-2">{f.title}</h3>
                <p className="text-[#555]">{f.body}</p>
              </motion.div>
            ))}
          </StaggerGroup>
    
      {/* Proof beat — understated, low motion */}
    
          <section className="py-24 border-t border-[#eee]">
            <Reveal y={8}>
              <p className="text-center text-sm tracking-widest uppercase text-[#999]">
    
            Trusted in early access by teams at
    
              </p>
              <div className="flex justify-center gap-12 mt-8 opacity-60 text-sm">
                <span>Arclight</span><span>Fieldnote</span><span>Loam</span>
              </div>
            </Reveal>
          </section>
    
      {/* Climax */}
    
          <section className="py-48 text-center px-6">
            <Reveal>
              <h2 className="text-4xl md:text-6xl font-medium tracking-tight mb-8">
                Your memory, kept.
              </h2>
              <button className="px-10 py-4 rounded-full bg-[#0A0A0B] text-white text-sm tracking-wide">
                Join the waitlist
              </button>
            </Reveal>
          </section>
        </main>
      );
    }
    

    Next steps: drop in real feature copy and logo assets, wire the waitlist
    buttons to your form handler, and if you want a punchier feel instead of
    restrained/luxury, swap EASE to cubic-bezier(0.65, 0, 0.35, 1) and bump
    the y-offsets from 20–24px to 40–80px per the kinetic/tech direction.

    NotelyLanding.jsx

    ZIP · project files

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Most "landing page" skills hand you a moodboard or a Tailwind starter. This one ships a directed motion system — a beat structure (cold open → rising beats → climax) so your page's energy actually builds instead of every section fading up the same way — plus production code in either React + Tailwind + Framer Motion or vanilla HTML/CSS/JS + GSAP (zero-dependency IntersectionObserver fallback included).

    What's inside

    Intake workflow that pins down tone (restrained/luxury, kinetic/tech, or editorial/film) before any code is written A motion system: one signature easing curve + duration scale per project, so pacing feels directed, not assembled Ready-to-use components: scroll reveal wrapper, staggered groups, scroll-linked parallax hero, word-stagger headline reveal Full typography scales and color-grading rules per tonal direction Built-in accessibility: every animated element ships a prefers-reduced-motion fallback, and parallax is clamped on mobile — most competing skills skip this entirely A pre-delivery self-check checklist so nothing ships half-finished

    Works with Claude Code, Cursor, Codex CLI, Gemini CLI, and any SKILL.md-compatible agent.

    Known Limitations

    • Produces code, not a hosted page — you still need a React/Next.js
      project (or a browser, for the vanilla build) to run the output; this
      skill doesn't deploy or host anything.

    • Framer Motion and GSAP are external dependencies. The React path
      requires npm install framer-motion; the vanilla path loads GSAP from
      a CDN. Only the IntersectionObserver fallback in vanilla-stack.md runs
      with zero dependencies, and it drops scroll-scrubbed parallax (GSAP's
      scrub: true) in exchange for simple on/off reveals.

    • Placeholder copy and imagery. If you don't supply real headlines,
      features, and images, the skill writes clearly marked [PLACEHOLDER]
      text and uses color-field/gradient stand-ins — it does not generate or
      source real photography, video, or final brand copy.

    • Three tonal directions, not infinite ones. Restrained/luxury,
      kinetic/tech, and editorial/film cover the type scale and color-grading
      defaults. A brand with an established design system will need its
      tokens substituted in manually — the skill won't infer your existing
      brand guidelines from a URL or logo.

    • No animation library beyond Framer Motion (React) or GSAP (vanilla).
      It won't output Vue/Svelte/Webflow-native animation code.

    • Motion choreography, not full page architecture. It assumes you're
      supplying content already organized as a single-scroll landing page;
      it doesn't handle multi-page navigation, CMS wiring, or backend/form
      integration for the CTA buttons.

    • Reduced-motion and mobile-parallax safeguards are built into every
      pattern in the reference files, but if you hand-write additional
      animations outside those patterns, you're responsible for adding the
      same fallbacks yourself.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 2 months ago

    Permissions

    No special permissions declared or detected

    Listed2 months ago

    What's inside

    Frequently Asked Questions

    Unlike standard builders that offer simple fade-ins, this engine uses a 'beat structure' motion system to orchestrate transitions, ensuring your page builds energy and narrative flow as the user scrolls.

    The engine provides production-ready code in two flavors: React with Framer Motion and Tailwind CSS, or vanilla HTML/CSS/JS using GSAP with a built-in IntersectionObserver fallback.

    Yes, every animation includes an automatic 'prefers-reduced-motion' fallback, and parallax effects are intelligently clamped on mobile devices to maintain performance and accessibility.

    This skill is fully compatible with SKILL.md-enabled environments, including Claude Code, Cursor, and various CLI-based agents like Gemini and Codex.

    You receive the full intake workflow, the directed motion system (easing curves and duration scales), a library of scroll-linked components, and a pre-delivery quality checklist.

    New in Frontend & Web Apps