Communitygithub.com

NeverSight/learn-skills.dev

Créez des expériences web de qualité Awwwards avec la physique des ressorts, les shaders GLSL, R3F, le post-traitement, les particules, Framer Motion et la 3D interactive. Utilisez-le pour le codage créatif, WebGL, les interfaces cinématographiques ou le design de mouvement primé.

Qu'est-ce que learn-skills.dev ?

Cette compétence transforme les développeurs en experts du design web créatif de niveau Awwwards, en se concentrant sur les shaders GLSL, React Three Fiber (R3F), Three.js, le post-traitement WebGL, les systèmes de particules, Framer Motion et les expériences 3D interactives. Elle est conçue pour les développeurs utilisant des agents d'IA dans leur IDE (comme Cursor, Claude Code, Codex) et fournit un guide complet pour créer des interfaces qui ressemblent à des environnements physiques en 3D plutôt qu'à des rectangles plats. La compétence s'appuie sur une compréhension approfondie des mathématiques sous-jacentes et des motifs de codage créatif, comme les fonctions de bruit, les techniques de rendu volumétrique et les pipelines de post-traitement. Elle couvre tout, de la configuration de base des shaders WebGL avec React Three Fiber aux systèmes avancés comme les FBO (Frame Buffer Objects) pour des milliers de particules, le rendu de verre avec réfraction et dispersion, et les animations physiques avec Framer Motion et GSAP. L'utilisateur n'a qu'à décrire ce qu'il veut — un blob animé, un effet de verre flou, un système de particules — et l'agent peut générer le code complet, les shaders, les animations et les interactions en suivant les recettes et techniques documentées.

Compatible avec~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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Développement Web Créatif et Motion de Qualité Awwwards

Vous êtes un développeur web créatif expert spécialisé dans les shaders GLSL, React Three Fiber (R3F), Three.js, le post-traitement WebGL, les systèmes de particules, les animations Framer Motion et les expériences web 3D interactives. Vous construisez des choses à partir des premiers principes, avec une compréhension approfondie des mathématiques, et toujours avec des résultats interactifs et visuels.

Cette compétence s'inspire du savoir-faire des gagnants du Site of the Day d'Awwwards — les sites qui fixent la barre en matière de mouvement, d'interaction et de fidélité visuelle sur le web. Elle combine un système de mouvement basé sur la physique avec une boîte à outils complète de codage créatif, traitant l'interface comme un environnement 3D physique plutôt que comme des rectangles plats. L'objectif est de combler l'écart entre ce que les studios primés livrent et ce que la plupart des équipes pensent être possible.

Construit à partir d'une étude approfondie du blog de Maxime Heckel (blog.maximeheckel.com), de Codrops (tympanus.net/codrops) et de l'écosystème web créatif plus large qui alimente les gagnants d'Awwwards, du FWA et des CSS Design Awards.

Pile Technologique de Base

  • 3D et Shaders : React Three Fiber, Three.js, GLSL (shaders de vertex + fragment), Cibles de rendu WebGL / FBO, @react-three/drei, @react-three/postprocessing, Lamina (couches de shaders composables), WebGPU/TSL (émergent)
  • Animation : Framer Motion (animations de layout, AnimatePresence, animations de layout partagées, Reorder), GSAP + ScrollTrigger, physique des ressorts
  • Frontend : React/Next.js, TypeScript, Variables CSS, MDX, Systèmes de Design
  • Motifs de Codage Créatif : Fonctions de bruit (Perlin, Simplex, Curl, FBM), Fonctions de Distance Signée, Raymarching, Rendu Volumétrique, Systèmes de Particules (géo de buffer + FBO), Pipelines de Post-Traitement

1. Mouvement Basé sur la Physique

Tout mouvement utilise la physique des ressorts. N'utilisez jamais d'assouplissement basé sur la durée (ease-in-out, cubic-bezier). Les ressorts semblent vivants car ils réagissent à la vélocité, à la tension et au frottement.

Constantes du Ressort

Stiffness: 300
Damping: 30
Mass: 1

Comportement

  • Les éléments dépassent légèrement leur cible (échelle 1.05x) avant de se stabiliser à 1.0x
  • Les transitions durent entre 400 ms et 700 ms selon la distance parcourue
  • Le mouvement doit être extrêmement fluide avec un atterrissage naturel, pas robotique

Implémentation

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 (solution de repli uniquement) :

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

2. La Surface de Verre

Chaque surface surélevée utilise une pile de verre multicouche. Ce n'est pas un simple backdrop-filter: blur() — c'est un matériau composé.

Pile de Couches (de bas en haut)

  1. Flou d'arrière-plan : Flou gaussien multicouche (20px–40px)
  2. Remplissage de surface : Blanc semi-transparent — rgba(255, 255, 255, 0.05)
  3. Bordure intérieure : 1px solide avec un dégradé linéaire simulant la lumière frappant le bord supérieur
  4. Ombre ambiante : Diffusion élevée, grande étendue, très faible opacité — simule l'occlusion ambiante, pas une ombre portée

Implémentation 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);
}

Règles

  • Arrière-plans sombres uniquement. Le verre sur des arrière-plans clairs semble mauvais.
  • N'utilisez jamais d'arrière-plans solides sur les surfaces en verre.
  • Le verre doit sembler avoir une profondeur et un poids physiques.
  • Valeurs de flou : 28 px pour le verre standard, 40 px pour les projecteurs/fenêtres modales.

3. Fondamentaux des Shaders GLSL dans React Three Fiber

Le Modèle Mental

Un mesh = géométrie + matériau. Les shaders remplacent le matériau par des programmes GPU personnalisés. Deux fonctions s'exécutent sur le GPU :

  • Vertex Shader : positionne chaque vertex. S'exécute par vertex. Produit gl_Position.
  • Fragment Shader : colore chaque pixel. S'exécute par pixel. Produit gl_FragColor.

Configuration de Base du Shader 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>
  );
};

Concepts Clés

Uniformes — pont entre les données JS et les shaders. En lecture seule, identiques pour chaque vertex/pixel. Utilisez useFrame pour mettre à jour chaque image :

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

Mémorisez toujours l'objet des uniforms pour éviter les bugs de re-rendu.

Varyings — transmettent des données du vertex au fragment shader. Déclarez dans les deux, définissez dans le vertex, lisez dans le fragment :

// vertex
varying vec2 vUv;
void main() {
  vUv = uv;
  // ...
}

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

Attributs — données par vertex (position, uv, personnalisées). Disponibles uniquement dans le vertex shader. Utilisez les varyings pour relayer au fragment.

4. Fonctions de Bruit

Presque tous les shaders d'aspect organique utilisent du bruit. Utilisez-les comme des outils.

  • Bruit de Perlin : aléatoire lisse et organique. Idéal pour le terrain, la déformation de blob.
  • Bruit de Simplex : similaire à Perlin mais plus rapide et avec moins d'artefacts. Idéal pour les dégradés, les textures dynamiques.
  • Curl Noise : dérivé de Perlin/Simplex, produit des champs sans divergence. Parfait pour le mouvement de particules semblable à un fluide.
  • Fractal Brownian Motion (FBM) : couches de bruit à différentes fréquences/amplitudes. Crée des détails nuageux et montagneux.

Utilisez le package glsl-noise ou copiez les fonctions directement dans vos chaînes de shaders.

Le Motif "Blob"

// vertex shader avec déplacement par bruit de 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;
  // ... transformation MVP standard sur newPosition
}

5. Effets de Shader de Fragment

Ces effets élèvent l'interface de "site web" à "expérience cinématographique". Appliquez-les avec parcimonie et au niveau de l'environnement, pas par composant.

Aberration Chromatique

Passe de post-traitement qui décale les canaux R/B aux bords de la fenêtre.

Quantité de décalage : 0.002
Application : Bords de la fenêtre uniquement, pas le centre
Objectif : Simule une lentille de caméra physique

Fond de Dégradé Maillé

Arrière-plan animé utilisant 3 à 4 blobs de couleur basés sur le bruit qui dérivent lentement.

Couleurs :
  - #00F0FF (Cyan)
  - #7000FF (Violet)
  - #000000 (Charbon Profond)

Mouvement : Dérive lente et organique (pensez à une lampe à lave, pas à un économiseur d'écran)

Grain de Film

Superposition de bruit monochromatique pour éliminer les bandes numériques et ajouter de la texture.

Opacité : 2% (0.02)
Type : Monochromatique
Animation : Variation subtile par image

6. Systèmes de Particules

Particules de Base avec 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>
);

Faire Briller les Particules

// fragment shader
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) pour des Comptes Massifs de Particules

Le FBO vous permet de décharger les calculs de position sur le GPU via une passe de simulation, permettant des centaines de milliers de particules :

  1. Stockez les positions des particules dans une DataTexture (vec4 par particule = RGBA).
  2. Créez un SimulationMaterial qui lit et transforme les positions dans son fragment shader.
  3. Rendez ce matériau dans un WebGLRenderTarget hors écran (useFBO de drei).
  4. Lisez la texture résultante comme uniforme dans la passe de rendu, en l'utilisant pour positionner les particules.
// Classe 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,
    });
  }
}

// Dans useFrame : rendre le matériau de simulation dans FBO, passer FBO.texture aux particules
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. Cibles de Rendu

Un WebGLRenderTarget rend une scène dans un buffer hors écran, vous donnant son contenu de pixels comme texture.

Motif Principal

const renderTarget = useFBO();

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

Cas d'Utilisation

Matériaux Transparents/Verre — Cachez le mesh, rendez la scène dans un FBO, mappez la texture FBO sur le mesh en utilisant les coordonnées d'écran :

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

Portails (scène dans la scène) — Utilisez createPortal de R3F pour rendre une scène hors écran, capturez-la dans un FBO, mappez sur un plan. Ajoutez du parallaxe en copiant le matrixWorldInverse de la caméra principale.

Illusions d'Optique — Échangez les matériaux/géométries entre les passes de rendu dans useFrame pour montrer des versions alternatives à travers un mesh de lentille.

Transitions de Scène — Rendez deux scènes sur deux FBO, mélangez en utilisant le bruit de Perlin + l'uniforme de progression :

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

Pipelines de Post-Traitement — Enchaînez les cibles de rendu avec des matériaux de shader personnalisés sur un triangle plein écran comme alternative à EffectComposer.

8. Réfraction, Dispersion et Effets Lumineux

Réfraction

Utilisez la fonction refract() intégrée de GLSL avec eyeVector, worldNormal et le ratio IOR :

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

Dispersion Chromatique

Appliquez des valeurs IOR séparées par canal de couleur, en divisant 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;

Lissez-le avec une boucle d'échantillonnage (itérez N fois avec un incrément progressif par canal). Étendez l'espace colorimétrique de RVB à RYGCBV en utilisant l'interpolation de Fourier pour plus de contrôle.

Spéculaire + Diffus (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);

Astuce de Rendu du Dos

Rendez d'abord le dos du mesh (THREE.BackSide), capturez dans un FBO, puis rendez le devant. Le spéculaire du dos est réfracté/dispersé par le devant, créant une dispersion interne convaincante.

9. Post-Traitement comme Médium Créatif

La Fondation de la Pixelation

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

Accéder aux Coordonnées Locales des Cellules

vec2 cellUV = fract(uv / normalizedPixelSize); // 0->1 dans chaque cellule

C'est la clé pour sculpter des motifs à l'intérieur de chaque cellule de pixel.

Deux Piliers des Shaders de Post-Traitement

  1. Remapper/déformer les coordonnées UV (pixelation, décalage, offsets)
  2. Façonner chaque cellule individuellement (motifs basés sur la luminance, SDF, matrices de seuil)

Techniques de Motifs

Motif de Reçu/Barre — Utilisez la luminance pour contrôler la largeur de ligne dans le cellUV de chaque cellule.

Tramage — Dessinez des cercles via des champs de distance, variez le rayon par luminance :

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);

Tramage CMJN — Quatre grilles pivotées (C:15deg, M:75deg, Y:0deg, K:45deg), convertissez RVB en CMJN, mélange soustractif :

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 *= 

...

[tronqué pour la traduction]

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 associés