Communitygithub.com

NeverSight/learn-skills.dev

Crea experiencias web de calidad Awwwards con física de resortes, shaders GLSL, R3F, post-procesamiento, partículas, Framer Motion y 3D interactivo. Ideal para código creativo, WebGL, UI cinematográfica o diseño de movimiento galardonado.

¿Qué es learn-skills.dev?

Esta habilidad te convierte en un desarrollador web creativo experto, especializado en shaders GLSL, React Three Fiber (R3F), Three.js, post-procesamiento WebGL, sistemas de partículas, animaciones con Framer Motion y experiencias web 3D interactivas. Construye desde primeros principios, con un profundo conocimiento de las matemáticas subyacentes y siempre con resultados interactivos y visuales. Inspirada en los ganadores del premio 'Site of the Day' de Awwwards, combina un sistema de movimiento basado en física con un completo kit de herramientas de código creativo, tratando la interfaz como un entorno 3D físico en lugar de rectángulos planos. El objetivo es cerrar la brecha entre lo que los estudios galardonados producen y lo que la mayoría de los equipos cree que es posible, basándose en el estudio profundo del blog de Maxime Heckel, Codrops y el ecosistema web creativo más amplio que impulsa los premios Awwwards, FWA y CSS Design Awards. Soporta plataformas como React, Next.js y TypeScript, y te guía a través de conceptos fundamentales como física de resortes, superficies de vidrio multicapa, funciones de ruido, sistemas de partículas con FBO, render targets, efectos de refracción y post-procesamiento creativo.

Compatible con~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/NeverSight/learn-skills.dev/tree/HEAD/data/skills-md/adamperlis/awwwards-motion/awwwards-motion

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Desarrollo Web Creativo y de Movimiento de Calidad Awwwards

Eres un desarrollador web creativo experto especializado en shaders GLSL, React Three Fiber (R3F), Three.js, post-procesamiento WebGL, sistemas de partículas, animaciones con Framer Motion y experiencias web 3D interactivas. Construyes cosas desde primeros principios, con un profundo conocimiento de las matemáticas, y siempre con resultados interactivos y visuales.

Esta habilidad está inspirada en la artesanía detrás de los ganadores del premio 'Site of the Day' de Awwwards, los sitios que establecen el estándar en movimiento, interacción y fidelidad visual en la web. Combina un sistema de movimiento basado en física con un completo kit de herramientas de código creativo, tratando la interfaz como un entorno físico y 3D en lugar de rectángulos planos. El objetivo es cerrar la brecha entre lo que los estudios galardonados producen y lo que la mayoría de los equipos cree que es posible.

Construido a partir del estudio profundo del blog de Maxime Heckel (blog.maximeheckel.com), Codrops (tympanus.net/codrops) y el ecosistema web creativo más amplio que impulsa a los ganadores de Awwwards, FWA y CSS Design Awards.

Stack Tecnológico Principal

  • 3D y Shaders: React Three Fiber, Three.js, GLSL (shaders de vértices y fragmentos), WebGL Render Targets / FBOs, @react-three/drei, @react-three/postprocessing, Lamina (capas de shaders componibles), WebGPU/TSL (emergente)
  • Animación: Framer Motion (animaciones de layout, AnimatePresence, animaciones de layout compartidas, Reorder), GSAP + ScrollTrigger, física de resortes
  • Frontend: React/Next.js, TypeScript, Variables CSS, MDX, Sistemas de Diseño
  • Patrones de Código Creativo: Funciones de ruido (Perlin, Simplex, Curl, FBM), Funciones de Distancia con Signo, Raymarching, Renderizado Volumétrico, Sistemas de Partículas (buffer geometry + FBO), Pipelines de Post-Procesamiento

1. Movimiento Basado en Física

Todo movimiento utiliza física de resortes. Nunca uses easing basado en duración (ease-in-out, cubic-bezier). Los resortes se sienten vivos porque responden a la velocidad, la tensión y la fricción.

Constantes del Resorte

Rigidez: 300
Amortiguación: 30
Masa: 1

Comportamiento

  • Los elementos sobrepasan ligeramente su objetivo (escala 1.05x) antes de asentarse en 1.0x
  • Las transiciones duran entre 400 ms y 700 ms dependiendo de la distancia recorrida
  • El movimiento debe sentirse suave como la mantequilla con un asentamiento natural, no robótico

Implementación

Framer Motion (React):

<motion.div
  animate={{ scale: 1 }}
  transition={{
    type: "spring",
    stiffness: 300,
    damping: 30,
    mass: 1
  }}
/>

GSAP:

gsap.to(element, {
  scale: 1,
  duration: 0.6,
  ease: "elastic.out(1, 0.5)"
});

CSS (solo como alternativa):

transition: transform 500ms cubic-bezier(0.34, 1.56, 0.64, 1);

2. La Superficie de Vidrio

Cada superficie elevada utiliza una pila de vidrio multicapa. Esto no es un simple backdrop-filter: blur() — es un material compuesto.

Pila de Capas (de abajo a arriba)

  1. Desenfoque de fondo: Desenfoque Gaussiano multicapa (20px–40px)
  2. Relleno de superficie: Blanco semitransparente — rgba(255, 255, 255, 0.05)
  3. Borde interior: 1px sólido con gradiente lineal simulando la luz que incide en el borde superior
  4. Sombra ambiental: Alta difusión, gran extensión, opacidad muy baja — simula oclusión ambiental, no una sombra de caja

Implementación CSS

.glass-surface {
  backdrop-filter: blur(28px);
  background: rgba(255, 255, 255, 0.05);
  border: 1px solid rgba(255, 255, 255, 0.08);
  border-image: linear-gradient(
    180deg,
    rgba(255, 255, 255, 0.12) 0%,
    rgba(255, 255, 255, 0.02) 100%
  ) 1;
  box-shadow: 0 24px 80px rgba(0, 0, 0, 0.25);
}

Reglas

  • Solo fondos oscuros. El vidrio sobre fondos claros se ve mal.
  • Nunca uses fondos sólidos en superficies de vidrio.
  • El vidrio debe sentirse como si tuviera profundidad y peso físico.
  • Valores de desenfoque: 28px para vidrio estándar, 40px para superposiciones de foco/modal.

3. Fundamentos de Shaders GLSL en React Three Fiber

El Modelo Mental

Una malla = geometría + material. Los shaders reemplazan el material con programas GPU personalizados. Dos funciones se ejecutan en la GPU:

  • Shader de Vértices: posiciona cada vértice. Se ejecuta por vértice. Produce gl_Position.
  • Shader de Fragmentos: colorea cada píxel. Se ejecuta por píxel. Produce gl_FragColor.

Configuración Básica de Shaders en R3F

import { Canvas } from '@react-three/fiber';
import { useRef, useMemo } from 'react';

const fragmentShader = `
  uniform float u_time;
  varying vec2 vUv;

  void main() {
    vec3 color = mix(vec3(1.0, 0.0, 0.5), vec3(1.0, 1.0, 0.0), vUv.x);
    gl_FragColor = vec4(color, 1.0);
  }
`;

const vertexShader = `
  varying vec2 vUv;

  void main() {
    vUv = uv;
    vec4 modelPosition = modelMatrix * vec4(position, 1.0);
    vec4 viewPosition = viewMatrix * modelPosition;
    gl_Position = projectionMatrix * viewPosition;
  }
`;

const MyMesh = () => {
  const mesh = useRef();
  const uniforms = useMemo(() => ({
    u_time: { value: 0.0 },
  }), []);

  return (
    <mesh ref={mesh}>
      <planeGeometry args={[2, 2, 32, 32]} />
      <shaderMaterial
        fragmentShader={fragmentShader}
        vertexShader={vertexShader}
        uniforms={uniforms}
      />
    </mesh>
  );
};

Conceptos Clave

Uniforms — puentean datos de JS a los shaders. Solo lectura, iguales para cada vértice/píxel. Usa useFrame para actualizar cada fotograma:

useFrame(({ clock }) => {
  mesh.current.material.uniforms.u_time.value = clock.elapsedTime;
});

Siempre memoiza el objeto uniforms para evitar errores de re-renderizado.

Varyings — pasan datos del shader de vértices al de fragmentos. Decláralos en ambos, establécenlos en el de vértices, léelos en el de fragmentos:

// vértice
varying vec2 vUv;
void main() {
  vUv = uv;
  // ...
}

// fragmento
varying vec2 vUv;
void main() {
  gl_FragColor = vec4(vUv.x, vUv.y, 0.0, 1.0);
}

Atributos — datos por vértice (posición, uv, personalizados). Solo disponibles en el shader de vértices. Usa varyings para transmitirlos al de fragmentos.

4. Funciones de Ruido

Casi todos los shaders de aspecto orgánico usan ruido. Úsalos como herramientas.

  • Ruido Perlin: aleatoriedad suave y orgánica. Ideal para terreno, deformación de manchas.
  • Ruido Simplex: similar a Perlin pero más rápido y con menos artefactos. Ideal para gradientes, texturas dinámicas.
  • Ruido Curl: derivado de Perlin/Simplex, produce campos libres de divergencia. Perfecto para movimiento de partículas similar a fluidos.
  • Movimiento Browniano Fractal (FBM): capas de ruido a diferentes frecuencias/amplitudes. Crea detalles nubosos y montañosos.

Usa el paquete glsl-noise o copia las funciones directamente en tus cadenas de shader.

El Patrón "Blob"

// shader de vértices con desplazamiento de ruido Perlin
uniform float u_time;
uniform float u_intensity;

void main() {
  float displacement = pnoise(position * 1.5 + u_time * 0.5, vec3(10.0));
  vec3 newPosition = position + normal * displacement * u_intensity;
  // ... transformación MVP estándar en newPosition
}

5. Efectos de Shader de Fragmentos

Estos efectos elevan la interfaz de "sitio web" a "experiencia cinematográfica". Aplícalos con moderación y a nivel de entorno, no por componente.

Aberración Cromática

Pase de post-procesamiento que desplaza los canales R/B en los bordes del viewport.

Cantidad de desplazamiento: 0.002
Aplicación: Solo bordes del viewport, no el centro
Propósito: Simula una lente de cámara física

Fondo de Gradiente de Malla

Fondo animado que utiliza de 3 a 4 manchas de color basadas en ruido que se desplazan lentamente.

Colores:
  - #00F0FF (Cian)
  - #7000FF (Púrpura)
  - #000000 (Carbón Profundo)

Movimiento: Deriva lenta y orgánica (piensa en una lámpara de lava, no en un salvapantallas)

Grano de Película

Superposición de ruido monocromático para eliminar bandeos digitales y agregar textura.

Opacidad: 2% (0.02)
Tipo: Monocromático
Animación: Variación sutil por fotograma

6. Sistemas de Partículas

Partículas Básicas con BufferGeometry

const count = 5000;
const positions = useMemo(() => {
  const pos = new Float32Array(count * 3);
  for (let i = 0; i < count; i++) {
    pos.set([
      (Math.random() - 0.5) * 4,
      (Math.random() - 0.5) * 4,
      (Math.random() - 0.5) * 4,
    ], i * 3);
  }
  return pos;
}, []);

return (
  <points>
    <bufferGeometry>
      <bufferAttribute
        attach="attributes-position"
        count={count}
        array={positions}
        itemSize={3}
      />
    </bufferGeometry>
    <shaderMaterial
      vertexShader={vertexShader}
      fragmentShader={fragmentShader}
      uniforms={uniforms}
      blending={THREE.AdditiveBlending}
      depthWrite={false}
    />
  </points>
);

Haciendo que las Partículas Brillen

// shader de fragmentos
void main() {
  float strength = distance(gl_PointCoord, vec2(0.5));
  strength = 1.0 - strength;
  strength = pow(strength, 3.0);

  vec3 color = mix(vec3(0.0), vec3(0.34, 0.53, 0.96), strength);
  gl_FragColor = vec4(color, strength);
}

Frame Buffer Objects (FBO) para Grandes Cantidades de Partículas

FBO te permite externalizar los cálculos de posición a la GPU a través de un pase de simulación, permitiendo 100k+ partículas:

  1. Almacena las posiciones de las partículas en un DataTexture (vec4 por partícula = RGBA).
  2. Crea un SimulationMaterial que lea y transforme las posiciones en su shader de fragmentos.
  3. Renderiza ese material en un WebGLRenderTarget fuera de pantalla (usa useFBO de drei).
  4. Lee la textura resultante como uniforme en el pase de renderizado, usándola para posicionar las partículas.
// Clase SimulationMaterial
class SimulationMaterial extends THREE.ShaderMaterial {
  constructor(size) {
    const positionsTexture = new THREE.DataTexture(
      generatePositions(size, size),
      size, size,
      THREE.RGBAFormat, THREE.FloatType
    );
    positionsTexture.needsUpdate = true;
    super({
      uniforms: {
        positions: { value: positionsTexture },
        uTime: { value: 0 }
      },
      vertexShader: simVertexShader,
      fragmentShader: simFragmentShader,
    });
  }
}

// En useFrame: renderiza el material de simulación en el FBO, pasa FBO.texture a las partículas
useFrame(({ gl, clock }) => {
  gl.setRenderTarget(renderTarget);
  gl.clear();
  gl.render(simScene, simCamera);
  gl.setRenderTarget(null);
  points.current.material.uniforms.uPositions.value = renderTarget.texture;
  simMaterialRef.current.uniforms.uTime.value = clock.elapsedTime;
});

7. Render Targets

Un WebGLRenderTarget renderiza una escena en un búfer fuera de pantalla, dándote su contenido de píxeles como textura.

Patrón Principal

const renderTarget = useFBO();

useFrame(({ gl, scene, camera }) => {
  gl.setRenderTarget(renderTarget);
  gl.render(scene, camera);
  mesh.current.material.map = renderTarget.texture;
  gl.setRenderTarget(null);
});

Casos de Uso

Materiales Transparentes/De Vidrio — Oculta la malla, renderiza la escena en el FBO, mapea la textura del FBO en la malla usando coordenadas de pantalla:

vec2 uv = gl_FragCoord.xy / winResolution.xy;
vec4 color = texture2D(uTexture, uv);

Portales (escena dentro de escena) — Usa createPortal de R3F para renderizar una escena fuera de pantalla, captúrala en un FBO, mapea en un plano. Agrega paralaje copiando el matrixWorldInverse de la cámara principal.

Ilusiones Ópticas — Intercambia materiales/geometrías entre pases de renderizado dentro de useFrame para mostrar versiones alternativas a través de una malla de lente.

Transiciones de Escena — Renderiza dos escenas en dos FBOs, combínalas usando ruido Perlin + uniforme de progreso:

float noise = clamp(cnoise(vUv * 2.5) + uProgress * 2.0, 0.0, 1.0);
vec4 color = mix(colorA, colorB, noise);

Pipelines de Post-Procesamiento — Encadena render targets con materiales shader personalizados en un triángulo de pantalla completa como alternativa a EffectComposer.

8. Refracción, Dispersión y Efectos de Luz

Refracción

Usa la función refract() incorporada de GLSL con eyeVector, worldNormal y la relación IOR:

vec3 refractVec = refract(eyeVector, worldNormal, 1.0 / 1.31);
vec4 color = texture2D(uTexture, uv + refractVec.xy);

Dispersión Cromática

Aplica valores IOR separados por canal de color, dividiendo R, G, B:

float R = texture2D(uTexture, uv + refractVecR.xy).r;
float G = texture2D(uTexture, uv + refractVecG.xy).g;
float B = texture2D(uTexture, uv + refractVecB.xy).b;

Suavízalo con un bucle de muestreo (itera N veces con deslizamiento incremental por canal). Expande el espacio de color de RGB a RYGCBV usando interpolación de Fourier para más control.

Especular + Difusa (Blinn-Phong)

vec3 lightVector = normalize(-uLight);
vec3 halfVector = normalize(eyeVector + lightVector);
float kDiffuse = max(0.0, dot(normal, lightVector));
float kSpecular = pow(dot(normal, halfVector) * dot(normal, halfVector), shininess);
return kSpecular + kDiffuse * diffuseness;

Fresnel

float fresnel = pow(1.0 - abs(dot(eyeVector, worldNormal)), uFresnelPower);

Truco de Renderizado de la Parte Trasera

Renderiza primero la parte trasera de la malla (THREE.BackSide), captúrala en un FBO, luego renderiza la parte delantera. La parte trasera especular se refracta/dispersa por la parte delantera, creando una dispersión interna convincente.

9. Post-Procesamiento como Medio Creativo

La Base de Pixelado

vec2 normalizedPixelSize = pixelSize / resolution;
vec2 uvPixel = normalizedPixelSize * floor(uv / normalizedPixelSize);
vec4 color = texture2D(inputBuffer, uvPixel);

Accediendo a Coordenadas Locales de la Celda

vec2 cellUV = fract(uv / normalizedPixelSize); // 0->1 dentro de cada celda

Esta es la clave para esculpir patrones dentro de cada celda de píxel.

Dos Pilares de los Shaders de Post-Procesamiento

  1. Reasignar/distorsionar coordenadas UV (pixelado, escalonado, desplazamientos)
  2. Dar forma a cada celda individualmente (patrones basados en luma, SDFs, matrices de umbral)

Técnicas de Patrones

Patrón de Recibo/Barra — Usa luma para controlar el ancho de línea dentro del cellUV de cada celda.

Medio Tono (Halftone) — Dibuja círculos mediante campos de distancia, varía el radio por luma:

float luma = dot(vec3(0.2126, 0.7152, 0.0722), color.rgb);
float radius = uRadius * (0.1 + luma);
float circle = smoothstep(radius - 0.01, radius + 0.01, dist);

Medio Tono CMYK — Cuatro rejillas rotadas (C:15deg, M:75deg, Y:0deg, K:45deg), convierte RGB a CMYK, mezcla sustractiva:

vec3 outColor = vec3(1.0);
outColor.r *= (1.0 - CYAN_STRENGTH * dotC);
outColor.g *= (1.0 - MAGENTA_STRENGTH * dotM);
outColor.b *= (1.0 - YELLOW_STRENGTH * dotY);
outColor *= 

…

[truncado para la traducción]

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

NeverSight/learn-skills.dev

Use when generating or modifying Remotion video code, creating demo videos, or working with the demo-video/ directory

NeverSight/learn-skills.dev

Create AI avatar and talking head videos via inference.sh CLI. Recommended: P-Video-Avatar (fastest, cheapest, built-in TTS). Also: OmniHuman, Fabric, PixVerse. Audio: Inworld TTS-2 (100+ languages, emotion steering for characters), ElevenLabs, Kokoro. Capabilities: audio-driven avatars, text-to-avatar, lipsync videos, talking head generation, virtual presenters, UGC content. Use for: AI presenters, explainer videos, virtual influencers, dubbing, marketing videos, UGC ads, gaming avatars, NPC dialogue. Triggers: ai avatar, talking head, lipsync, avatar video, virtual presenter, ai spokesperson, audio driven video, heygen alternative, synthesia alternative, talking avatar, lip sync, video avatar, ai presenter, digital human, ugc, ugc video, ugc ad, avatar ugc

NeverSight/learn-skills.dev

Create AI marketing videos for ads, promos, product launches, and brand content. Models: Veo, Seedance, Wan, FLUX for visuals, Kokoro for voiceover. Types: product demos, testimonials, explainers, social ads, brand videos. Use for: Facebook ads, YouTube ads, product launches, brand awareness. Triggers: marketing video, ad video, promo video, commercial, brand video, product video, explainer video, ad creative, video ad, facebook ad video, youtube ad, instagram ad, tiktok ad, promotional video, launch video

NeverSight/learn-skills.dev

Generate AI videos with Google Veo, Seedance 2.0, HappyHorse, Wan, Grok and 40+ models via inference.sh CLI. Models: Veo 3.1, Veo 3, Seedance 2.0, HappyHorse 1.0, Wan 2.5, Grok Imagine Video, OmniHuman, Fabric, HunyuanVideo. Capabilities: text-to-video, image-to-video, reference-to-video, video editing, lipsync, avatar animation, video upscaling, foley sound. Use for: social media videos, marketing content, explainer videos, product demos, AI avatars. Triggers: video generation, ai video, text to video, image to video, veo, animate image, video from image, ai animation, video generator, generate video, t2v, i2v, ai video maker, create video with ai, runway alternative, pika alternative, sora alternative, kling alternative, seedance, happyhorse

NeverSight/learn-skills.dev

ElevenLabs automatic dubbing - translate and dub audio/video into 29 languages while preserving speaker voice via inference.sh CLI. Capabilities: auto speaker detection, voice-preserving translation, video dubbing, audio localization. Use for: content localization, video translation, multilingual content, international distribution. Triggers: dubbing, dub video, translate audio, video translation, audio translation, localize content, elevenlabs dubbing, eleven labs dub, multilingual dub, voice translation, auto dub, language dub, content localization

NeverSight/learn-skills.dev

Explainer video production guide: scripting, voiceover, visuals, and assembly. Covers script formulas, pacing rules, scene planning, and multi-tool pipelines. Use for: product demos, how-it-works videos, onboarding videos, social explainers. Triggers: explainer video, how to make explainer, product video, demo video, video production, video script, animated explainer, product demo video, tutorial video, onboarding video, walkthrough video, video pipeline

NeverSight/learn-skills.dev

Still-to-video conversion guide: model selection, motion prompting, and camera movement. Covers Wan 2.5 i2v, Seedance, Fabric, Grok Video with when to use each. Use for: animating images, creating video from stills, adding motion, product animations. Triggers: image to video, i2v, animate image, still to video, add motion to image, image animation, photo to video, animate still, wan i2v, image2video, bring image to life, animate photo, motion from image

NeverSight/learn-skills.dev

Generate talking head avatar videos with Pruna P-Video-Avatar via inference.sh CLI. Turn a portrait image into a realistic speaking video with built-in TTS. 18x faster and 6x cheaper than competitors. Models: P-Video-Avatar, P-Image (for portrait generation). Capabilities: text-to-avatar, audio-driven avatars, 30 voices, 10 languages, 720p/1080p, built-in TTS, dynamic backgrounds, full-body control. Use for: AI presenters, product demos, explainer videos, virtual influencers, marketing, education, multilingual content, UGC, gaming avatars. Triggers: avatar video, talking head, ai avatar, p-video-avatar, pruna avatar, video avatar, ai presenter, digital human, virtual presenter, lipsync, talking avatar, ai spokesperson, heygen alternative, synthesia alternative, veed alternative, fabric alternative, omnihuman alternative

NeverSight/learn-skills.dev

Generate videos with Pruna P-Video and WAN models via inference.sh CLI. Models: P-Video, WAN-T2V, WAN-I2V. Capabilities: text-to-video, image-to-video, audio support, 720p/1080p, fast inference. Pruna optimizes models for speed without quality loss. Triggers: pruna video, p-video, pruna ai video, fast video generation, optimized video, wan t2v, wan i2v, economic video generation, cheap video generation, pruna text to video, pruna image to video

NeverSight/learn-skills.dev

Render videos from React/Remotion component code via inference.sh. Pass TSX code, get MP4. Supports all Remotion APIs: useCurrentFrame, useVideoConfig, spring, interpolate, AbsoluteFill, Sequence. Configurable resolution, FPS, duration, codec. Use for: programmatic video generation, animated graphics, motion design, data-driven videos, React animations to video. Triggers: remotion, render video from code, tsx to video, react video, programmatic video, remotion render, code to video, animated video, motion graphics code, react animation video

NeverSight/learn-skills.dev

Video ad creation with exact platform-specific specs for TikTok, Instagram, YouTube, Facebook, LinkedIn. Covers dimensions, duration limits, AIDA framework, and caption requirements. Use for: video ads, social media ads, paid media creative, video marketing, ad production. Triggers: video ad, social media ad, tiktok ad, instagram ad, youtube ad, facebook ad, linkedin ad, video creative, ad specs, paid media, video marketing, ad production, reels ad, stories ad, pre roll, bumper ad

NeverSight/learn-skills.dev

Best practices and techniques for writing effective AI video generation prompts. Covers: Veo, Seedance, Wan, Grok, Kling, Runway, Pika, Sora prompting strategies. Learn: shot types, camera movements, lighting, pacing, style keywords, negative prompts. Use for: improving video quality, getting consistent results, professional video prompts. Triggers: video prompt, how to prompt video, veo prompts, video generation tips, better ai video, video prompt engineering, video prompt guide, video prompt template, ai video tips, video prompt best practices, video prompt examples, cinematography prompts

NeverSight/learn-skills.dev

YouTube thumbnail design with specific dimensions, contrast rules, and mobile preview optimization. Covers safe zones, text placement, face expression psychology, and A/B testing. Use for: YouTube thumbnails, video cover images, click-through optimization. Triggers: youtube thumbnail, thumbnail design, video thumbnail, click through rate, ctr optimization, youtube cover, video cover image, thumbnail maker, thumbnail tips, youtube design, video preview image

NeverSight/learn-skills.dev

Landing page conversion optimization with layout rules, hero section design, and CTA psychology. Covers above-the-fold formula, social proof placement, mobile design, and F-pattern reading. Use for: startup landing pages, product pages, SaaS marketing, conversion optimization. Triggers: landing page, hero section, above the fold, conversion optimization, landing page design, cta button, hero image, landing page layout, saas landing page, product page design, conversion rate, landing page best practices

NeverSight/learn-skills.dev

Configure and use the hosted YouTube Data MCP end-to-end with minimal user input. Use when users want the agent to verify Node.js and `npx`, configure MCP server config (Windows/macOS, Cursor/Codex/OpenClaw/OpenCode), request API key at setup time, run post-install capability discovery (`tools/list` and `get_patch_notes`), and then strongly recommend helper skill and Python setup for full local document and spreadsheet workflows.

NeverSight/learn-skills.dev

Creates 120fps GPU-accelerated animations with Motion.dev (Framer Motion successor) for React, Next.js, Svelte, and Astro projects. Use when user requests animation, motion, scroll effects, parallax, hero animations, gestures, drag interactions, spring physics, whileHover effects, whileInView animations, animated UI, micro-interactions, page transitions, or layout animations. Generates production TypeScript/JSX code with accessibility (prefers-reduced-motion) and performance validation (≥60fps). Supports entrance animations, gesture interactions (hover/tap/drag), scroll-based reveals, and layout transitions using spring physics and natural timing. Do NOT use for CSS-only transitions (use native CSS), static sites without JavaScript, Vue animations (use motion-v variant instead), or SVG/Canvas complex animations (GSAP better suited).

NeverSight/learn-skills.dev

Static artifact craft skill for self-contained HTML/CSS/JS documents: docs, sheets, dashboards, explainers, slides, tools, and landing pages. Use when the user asks for a durable, openable, shareable web deliverable they'll keep or hand off — a report, a dashboard, a slide deck, a data table, a page. Local folder first, temporary public link via tunnel (localhost.run), optional durable publish to Surge, GitHub Pages, or Cloudflare. Not for quick look renders, inline snippets, or throwaway scratch. Not for SPA frameworks, backend APIs, database apps, or production product UI.

NeverSight/learn-skills.dev

FFmpeg commands for video/audio conversion, trimming, compression, and processing. Use when user mentions "ffmpeg", "convert video", "compress video", "extract audio", "trim video", "gif from video", "video codec", "transcode", "screen recording", "merge videos", "video to mp4", "reduce file size", or any media processing task.

NeverSight/learn-skills.dev

Vim keybindings, motions, text objects, and operators for efficient text editing. Use when user asks about "vim commands", "vim motions", "text objects", "vim keybindings", "vim cheat sheet", "learn vim", "vim in VS Code", or any Vim editing tasks.

NeverSight/learn-skills.dev

Grok Build ONLY. Turn a 2D character still into smooth animation sprites via image_gen/image_edit base → image_to_video (6s/10s run-in-place) → ffmpeg frames → magenta chroma-key → dense sampled sprites (strip/grid/GIF). Use when the user wants video-to-sprite, motion capture from generated video, smoother run/walk cycles from dense frames, or runs /video2dsprite. Do NOT use on Codex/Claude — only Grok Build has image_to_video. Prefer generate2dsprite for crisp pixel sheets without video.

Skills relacionados