Agent skill

Spline Interactive

by freshtechbro in freshtechbro/claudedesignskills

Browser-based 3D design tool with visual editor, animation, and web export.

MITAuto-check passedGame Development

Install Spline Interactive

skills CLI
$ npx skills add freshtechbro/claudedesignskills --skill spline-interactive -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install freshtechbro/claudedesignskills spline-interactive --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/freshtechbro/claudedesignskills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/spline-interactive .claude/skills/spline-interactive && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
spline-interactive
GitHub stars
994
Token cost
~4.9k tokens
SKILL.md length
972 words
Files
5 (incl. scripts, references, assets)
Skills in repo
19
Repo updated
First seen
Licence
MIT

At a glance

Browser-based 3D design tool with visual editor, animation, and web export.

  • Works in 10 steps: Scene Structure → Components System → State-Based Animation → …
  • Creating 3D scenes without code
  • SKILL.md covers Overview, Core Concepts, Common Patterns and Integration Patterns, plus 2 more sections
  • Runs Python scripts from its folder; calls npm; reaches prod.spline.design

What it does

Spline Interactive is an agent skill from freshtechbro/claudedesignskills. Browser-based 3D design tool with visual editor, animation, and web export. Use this skill when creating 3D scenes without code, designing interactive web experiences, prototyping 3D UI, exporting to React/web, or building designer-friendly 3D content. Triggers on tasks involving Spline, no-code 3D, visual 3D editor, 3D animation, state-based interactions, React Spline integration, or scene export. Alternative to Three.js for designers who prefer visual tools over code.

Its SKILL.md is about 4.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 7 other files, including scripts, reference files and assets (for example `assets/README.md`, `references/api_reference.md` and `scripts/component_builder.py`).

It sits in Game Development, covering 3D graphics and WebGL and Prototyping. It works with React and Three.js. The repository describes itself as: A comprehensive collection of Claude Code skills for modern web development, specializing in 3D graphics, animation, and interactive web experiences. The licence is MIT.

When your agent uses it

  • Creating 3D scenes without code
  • Designing interactive web experiences
  • Prototyping 3D UI
  • Exporting to React/web

Example prompts

  • “/spline-interactive”

Requirements

  • Python 3
  • Node.js

Workflow steps

10 steps, taken from the step headings in SKILL.md.

  1. Scene Structure
  2. Components System
  3. State-Based Animation
  4. Interactivity Model
  5. Export Options
  6. Enable On-Demand Rendering
  7. Optimize Scene in Spline Editor
  8. Lazy Load Heavy Scenes
  9. Preload Critical Scenes
  10. Mobile Optimizations

What it can do on your machine

Read from SKILL.md and the folder at commit 1da73fe. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • npm

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • prod.spline.design

    Also links to:

    • spline.design
    • docs.spline.design
    • github.com
    • spline.community

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Spline Interactive loads about 4.9k tokens when it runs, and up to ~8.1k if it reads all its reference files. Until then it costs about 123 tokens; SKILL.md has 972 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~123
When it runs · the whole SKILL.md, loaded when a task matches
~4.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~8.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from freshtechbro/claudedesignskills at commit 1da73fe, republished under its MIT licence (© freshtechbro). 972 words, ~4,880 tokens.

Download SKILL.mdSave it as .claude/skills/spline-interactive/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
spline-interactive
description
Browser-based 3D design tool with visual editor, animation, and web export. Use this skill when creating 3D scenes without code, designing interactive web experiences, prototyping 3D UI, exporting to React/web, or building designer-friendly 3D content. Triggers on tasks involving Spline, no-code 3D, visual 3D editor, 3D animation, state-based interactions, React Spline integration, or scene export. Alternative to Three.js for designers who prefer visual tools over code.

Spline Interactive - Browser-Based 3D Design and Animation

Overview

Spline is a browser-based 3D design and animation platform that enables creators to build interactive 3D experiences without requiring code or specialized software knowledge. It provides a collaborative visual editor for designing, animating, and exporting 3D scenes across multiple platforms.

Key Features:

  • Visual 3D modeling with parametric shapes, extrusion, and boolean operations
  • State-based animation system with timeline controls
  • Interactive event system (mouse, keyboard, collision, scroll)
  • Multiple export options (React components, web code, public URLs)
  • Real-time collaboration with team libraries
  • AI-powered generation (3D from text, textures, style transfer)
  • Built-in physics and particle systems

When to Use This Skill:

  • Creating 3D web experiences without writing Three.js code
  • Designing interactive product showcases or configurators
  • Prototyping 3D UI/UX concepts visually
  • Building marketing pages with 3D elements
  • Collaborating with designers on 3D content
  • Exporting scenes for React or vanilla JS integration

Alternatives:

  • Three.js (threejs-webgl): For developers who prefer code-first approach and need maximum control
  • Babylon.js (babylonjs-engine): For game-focused projects with built-in physics
  • React Three Fiber (react-three-fiber): For React developers who want to build 3D with JSX

Core Concepts

1. Scene Structure

Spline organizes projects into scenes containing:

  • Objects: 3D models, shapes, text, images
  • Lights: Directional, point, spot lights
  • Cameras: Orbital, perspective, orthographic
  • Events: Interaction triggers
  • States: Animation keyframes
2. Components System

Reusable elements that can be:

  • Created from any object or group
  • Instantiated multiple times
  • Updated across all instances
  • Overridden per instance
3. State-Based Animation

Animations are defined as transitions between states:

  • Default State: Initial appearance
  • Additional States: Target appearances
  • Events: Triggers that cause state transitions
  • Transitions: Duration, easing, properties
4. Interactivity Model

Event-driven system with:

  • Events: User actions or scene triggers
  • Conditions: Logic gates (if/else)
  • Actions: State changes, audio, scene switches
  • Variables: Dynamic data from APIs or user input
5. Export Options

Multiple deployment methods:

  • Public URL: Direct shareable link
  • Code Export: React component or vanilla JS
  • Spline Viewer: Embedded iframe
  • Self-Hosted: Download and host independently

Common Patterns

Pattern 1: Basic React Integration

Use Case: Embed a Spline scene in a React application

Implementation:

bash
# Installation
npm install @splinetool/react-spline @splinetool/runtime
jsx
import Spline from '@splinetool/react-spline';

export default function Hero() {
  return (
    <div style={{ width: '100%', height: '600px' }}>
      <Spline scene="https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode" />
    </div>
  );
}

Key Points:

  • Scene URL comes from Spline export dialog
  • Component fills parent container
  • Automatically handles loading and rendering
Pattern 2: Event Handling and Object Interaction

Use Case: Respond to user clicks on specific objects

Implementation:

jsx
import Spline from '@splinetool/react-spline';

export default function InteractiveScene() {
  function onSplineMouseDown(e) {
    // Check if clicked object is the button
    if (e.target.name === 'Button') {
      console.log('Button clicked!');

      // Get object properties
      console.log('Position:', e.target.position);
      console.log('Rotation:', e.target.rotation);
      console.log('Scale:', e.target.scale);
    }
  }

  function onSplineMouseHover(e) {
    if (e.target.name === 'Button') {
      console.log('Hovering over button');
    }
  }

  return (
    <Spline
      scene="https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode"
      onSplineMouseDown={onSplineMouseDown}
      onSplineMouseHover={onSplineMouseHover}
    />
  );
}

Available Event Handlers:

  • onSplineMouseDown - Mouse press on object
  • onSplineMouseUp - Mouse release
  • onSplineMouseHover - Mouse over object
  • onSplineKeyDown - Keyboard press
  • onSplineKeyUp - Keyboard release
  • onSplineStart - Scene loaded and started
  • onSplineLookAt - Camera look-at event
  • onSplineFollow - Camera follow event
  • onSplineScroll - Scroll event
Pattern 3: Programmatic Object Control

Use Case: Modify object properties from React code

Implementation:

jsx
import { useRef } from 'react';
import Spline from '@splinetool/react-spline';

export default function ProductViewer() {
  const cube = useRef();
  const splineApp = useRef();

  function onLoad(spline) {
    // Save Spline instance
    splineApp.current = spline;

    // Find object by name
    const obj = spline.findObjectByName('Product');
    // Or by ID
    // const obj = spline.findObjectById('8E8C2DDD-18B6-4C54-861D-7ED2519DE20E');

    cube.current = obj;
  }

  function rotateProduct() {
    if (cube.current) {
      // Rotate 45 degrees around Y axis
      cube.current.rotation.y += Math.PI / 4;
    }
  }

  function changeColor() {
    if (cube.current) {
      // Change material color (hex color)
      cube.current.material.color.set(0xff6b6b);
    }
  }

  function moveProduct() {
    if (cube.current) {
      cube.current.position.x += 50;
      cube.current.position.y += 10;
    }
  }

  return (
    <div>
      <Spline
        scene="https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode"
        onLoad={onLoad}
      />
      <div style={{ position: 'absolute', top: 20, left: 20 }}>
        <button onClick={rotateProduct}>Rotate</button>
        <button onClick={changeColor}>Change Color</button>
        <button onClick={moveProduct}>Move</button>
      </div>
    </div>
  );
}

Object Properties You Can Modify:

  • position - { x, y, z }
  • rotation - { x, y, z } (radians)
  • scale - { x, y, z }
  • material.color - Color hex value
  • visible - Boolean
Pattern 4: Triggering Spline Animations

Use Case: Trigger animations defined in Spline from React

Implementation:

jsx
import { useRef } from 'react';
import Spline from '@splinetool/react-spline';

export default function AnimatedCard() {
  const splineApp = useRef();

  function onLoad(app) {
    splineApp.current = app;
  }

  function triggerHoverAnimation() {
    // Emit mouseHover event on 'Card' object
    splineApp.current.emitEvent('mouseHover', 'Card');
  }

  function triggerClickAnimation() {
    // Emit mouseDown event on 'Button' object
    splineApp.current.emitEvent('mouseDown', 'Button');
  }

  function reverseAnimation() {
    // Play animation in reverse
    splineApp.current.emitEventReverse('mouseHover', 'Card');
  }

  return (
    <div>
      <Spline
        scene="https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode"
        onLoad={onLoad}
      />
      <button onClick={triggerHoverAnimation}>Hover Effect</button>
      <button onClick={triggerClickAnimation}>Click Effect</button>
      <button onClick={reverseAnimation}>Reverse</button>
    </div>
  );
}

Available Event Types:

  • mouseDown - Mouse press
  • mouseHover - Hover effect
  • mouseUp - Mouse release
  • keyDown - Key press
  • keyUp - Key release
  • start - Start event
  • lookAt - Look at camera
  • follow - Follow camera
Pattern 5: Next.js Integration with SSR

Use Case: Use Spline in Next.js with server-side rendering benefits

Implementation:

jsx
// app/page.js (Next.js 13+ App Router)
import Spline from '@splinetool/react-spline/next';

export default function Home() {
  return (
    <main>
      <div style={{ width: '100vw', height: '100vh' }}>
        <Spline scene="https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode" />
      </div>
    </main>
  );
}

Benefits:

  • Placeholder image shown during SSR
  • Faster perceived load times
  • Better SEO with fallback content
Pattern 6: Lazy Loading for Performance

Use Case: Defer Spline loading until needed

Implementation:

jsx
import React, { Suspense } from 'react';

// Dynamically import Spline
const Spline = React.lazy(() => import('@splinetool/react-spline'));

export default function LazyScene() {
  return (
    <div>
      <h1>My Page Content</h1>

      <Suspense fallback={<div>Loading 3D scene...</div>}>
        <div style={{ width: '100%', height: '500px' }}>
          <Spline scene="https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode" />
        </div>
      </Suspense>

      <p>More content below</p>
    </div>
  );
}

Benefits:

  • Reduces initial bundle size
  • Improves page load performance
  • Shows custom loading UI
Pattern 7: Responsive Spline Scenes

Use Case: Make Spline scenes adapt to different screen sizes

Implementation:

jsx
import Spline from '@splinetool/react-spline';
import { useState, useEffect } from 'react';

export default function ResponsiveScene() {
  const [isMobile, setIsMobile] = useState(false);

  useEffect(() => {
    const checkMobile = () => {
      setIsMobile(window.innerWidth < 768);
    };

    checkMobile();
    window.addEventListener('resize', checkMobile);
    return () => window.removeEventListener('resize', checkMobile);
  }, []);

  return (
    <div style={{
      width: '100%',
      height: isMobile ? '400px' : '600px'
    }}>
      <Spline
        scene={
          isMobile
            ? "https://prod.spline.design/YOUR-MOBILE-SCENE/scene.splinecode"
            : "https://prod.spline.design/YOUR-DESKTOP-SCENE/scene.splinecode"
        }
      />
    </div>
  );
}

Alternative Approach (Single Scene):

jsx
import Spline from '@splinetool/react-spline';
import { useRef, useEffect } from 'react';

export default function ResponsiveScene() {
  const splineApp = useRef();

  function onLoad(app) {
    splineApp.current = app;
    adjustForScreenSize();
  }

  function adjustForScreenSize() {
    if (!splineApp.current) return;

    const camera = splineApp.current.findObjectByName('Camera');
    const isMobile = window.innerWidth < 768;

    if (isMobile) {
      // Zoom out on mobile
      splineApp.current.setZoom(0.7);
      // Adjust camera position
      camera.position.z = 1500;
    }
  }

  useEffect(() => {
    window.addEventListener('resize', adjustForScreenSize);
    return () => window.removeEventListener('resize', adjustForScreenSize);
  }, []);

  return (
    <Spline
      scene="https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode"
      onLoad={onLoad}
    />
  );
}

Integration Patterns

Show full SKILL.md (400 more words)Show less
With Three.js (threejs-webgl)

For advanced use cases, combine Spline-designed assets with Three.js code:

  1. Export from Spline: Use GLTF/GLB export
  2. Import in Three.js: Load using GLTFLoader
  3. Enhance with code: Add custom shaders, physics, or effects
javascript
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';

const loader = new GLTFLoader();
loader.load('spline-model.glb', (gltf) => {
  scene.add(gltf.scene);
  // Add custom behaviors
});
With GSAP (gsap-scrolltrigger)

Trigger Spline animations on scroll:

jsx
import { useEffect, useRef } from 'react';
import Spline from '@splinetool/react-spline';
import gsap from 'gsap';
import ScrollTrigger from 'gsap/ScrollTrigger';

gsap.registerPlugin(ScrollTrigger);

export default function ScrollAnimated() {
  const splineApp = useRef();

  function onLoad(app) {
    splineApp.current = app;

    ScrollTrigger.create({
      trigger: '.scene-container',
      start: 'top center',
      onEnter: () => {
        app.emitEvent('mouseHover', 'Product');
      }
    });
  }

  return (
    <div className="scene-container">
      <Spline
        scene="https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode"
        onLoad={onLoad}
      />
    </div>
  );
}
With Framer Motion (motion-framer)

Animate container while Spline handles 3D:

jsx
import { motion } from 'framer-motion';
import Spline from '@splinetool/react-spline';

export default function AnimatedContainer() {
  return (
    <motion.div
      initial={{ opacity: 0, y: 50 }}
      animate={{ opacity: 1, y: 0 }}
      transition={{ duration: 0.8 }}
      style={{ width: '100%', height: '600px' }}
    >
      <Spline scene="https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode" />
    </motion.div>
  );
}

Performance Optimization

1. Enable On-Demand Rendering

Render only when scene changes, not every frame:

jsx
<Spline
  scene="https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode"
  renderOnDemand={true} // Default is true
/>
2. Optimize Scene in Spline Editor

In Spline:

  • Reduce polygon count (use decimation)
  • Compress textures (lower resolution, use JPG over PNG)
  • Limit lights (2-3 lights maximum)
  • Use simple materials when possible
  • Enable LOD (Level of Detail) for distant objects
3. Lazy Load Heavy Scenes

Use React.lazy() as shown in Pattern 6

4. Preload Critical Scenes
jsx
import { useEffect } from 'react';
import Spline from '@splinetool/react-spline';

export default function PreloadedScene() {
  useEffect(() => {
    // Preload scene assets
    const link = document.createElement('link');
    link.rel = 'prefetch';
    link.href = 'https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode';
    document.head.appendChild(link);
  }, []);

  return (
    <Spline scene="https://prod.spline.design/YOUR-SCENE-ID/scene.splinecode" />
  );
}
5. Mobile Optimizations
  • Create separate mobile scenes with lower detail
  • Reduce canvas resolution on mobile
  • Disable shadows and reflections
  • Use simpler materials
jsx
<Spline
  scene={isMobile ? mobileSceneUrl : desktopSceneUrl}
  style={{
    width: '100%',
    height: isMobile ? '300px' : '600px'
  }}
/>

Common Pitfalls and Solutions

Pitfall 1: Scene Not Loading

Problem: Spline component renders but scene doesn't appear

Solutions:

jsx
// ❌ Wrong: Invalid scene URL
<Spline scene="my-scene.splinecode" />

// ✅ Correct: Full URL from Spline export
<Spline scene="https://prod.spline.design/KFonZGtsoUXP-qx7/scene.splinecode" />

// Check for errors
function onLoad(app) {
  console.log('Scene loaded successfully', app);
}

<Spline scene={sceneUrl} onLoad={onLoad} />

Also Check:

  • Scene is published in Spline editor
  • Network tab shows successful file downloads
  • No CORS errors in console
Pitfall 2: Object References Lost After Re-render

Problem: Object refs become undefined after component updates

Solution:

jsx
// ❌ Wrong: Storing objects without proper refs
let myObject;

function onLoad(spline) {
  myObject = spline.findObjectByName('Cube'); // Lost on re-render
}

// ✅ Correct: Use React refs
const myObject = useRef();

function onLoad(spline) {
  myObject.current = spline.findObjectByName('Cube');
}
Pitfall 3: Performance Issues on Mobile

Problem: Scene runs slowly on mobile devices

Solutions:

jsx
// Create mobile-optimized version in Spline editor
// - Fewer polygons (< 50k triangles)
// - Smaller textures (512x512 or less)
// - No shadows or reflections
// - Simpler materials

// Load appropriate version
const isMobile = window.innerWidth < 768;
const sceneUrl = isMobile
  ? 'https://prod.spline.design/MOBILE-SCENE/scene.splinecode'
  : 'https://prod.spline.design/DESKTOP-SCENE/scene.splinecode';

<Spline scene={sceneUrl} renderOnDemand={true} />
Pitfall 4: Events Not Firing

Problem: Click or hover events don't trigger

Solutions:

jsx
// ❌ Wrong: Using wrong event name
<Spline onMouseDown={handler} /> // Not a Spline prop

// ✅ Correct: Use Spline event props
<Spline onSplineMouseDown={handler} />

// Also ensure object has events in Spline editor:
// 1. Select object in Spline
// 2. Add event in "Events" panel
// 3. Assign state transition or action
Pitfall 5: Animation Not Triggering Programmatically

Problem: emitEvent() doesn't trigger animation

Solutions:

jsx
// ❌ Wrong: Calling before scene loads
function triggerAnimation() {
  splineApp.current.emitEvent('mouseHover', 'Button'); // Error if not loaded
}

// ✅ Correct: Ensure scene is loaded
const [isLoaded, setIsLoaded] = useState(false);

function onLoad(app) {
  splineApp.current = app;
  setIsLoaded(true);
}

function triggerAnimation() {
  if (isLoaded && splineApp.current) {
    splineApp.current.emitEvent('mouseHover', 'Button');
  }
}

// Also verify in Spline editor:
// - Object has the correct name ('Button')
// - mouseHover event is configured
// - Event has action (state transition, etc.)
Pitfall 6: Hydration Errors in Next.js

Problem: Mismatch between server and client render

Solution:

jsx
// ❌ Wrong: Using standard import in Next.js
import Spline from '@splinetool/react-spline';

// ✅ Correct: Use Next.js-specific import
import Spline from '@splinetool/react-spline/next';

// Or use dynamic import with ssr: false
import dynamic from 'next/dynamic';

const Spline = dynamic(
  () => import('@splinetool/react-spline'),
  { ssr: false }
);

Resources

Official Documentation
Spline Editor
Learning Resources
Export Formats
  • React component (via @splinetool/react-spline)
  • Vanilla JavaScript (Web Code API)
  • GLTF/GLB (for Three.js, Babylon.js)
  • USDZ (for Apple AR)
  • STL (for 3D printing)
  • Video/GIF (for marketing)
  • threejs-webgl: For code-first 3D development with more control
  • react-three-fiber: For building 3D scenes with React and JSX
  • babylonjs-engine: Alternative 3D engine with editor workflow
  • motion-framer: For animating Spline containers and UI elements
  • gsap-scrolltrigger: For scroll-driven Spline animations
  • figma-dev-mode: For design-to-code workflow (similar visual approach)

Scripts

This skill includes utility scripts:

  • project_generator.py - Generate Spline + React starter projects
  • component_builder.py - Build Spline component wrappers with events

Run scripts from the skill directory:

bash
./scripts/project_generator.py
./scripts/component_builder.py

Assets

Starter templates and examples:

  • starter_spline/ - Complete React + Spline template
  • examples/ - Real-world integration patterns

© freshtechbro, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 4 other files (scripts, references, assets) in .claude/skills/spline-interactive of freshtechbro/claudedesignskills.

  • SKILL.md
  • assets/README.md
  • references/api_reference.md
  • scripts/component_builder.py
  • scripts/project_generator.py

Open the folder on GitHubat commit 1da73fe

Compare with similar skills

Spline Interactive next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Spline Interactive compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Spline Interactive this skillfreshtechbro/claudedesignskills994—~4.9kAutomated safety check: PassMIT
Polycsslayoutit/polycss759—~2.4kAutomated safety check: PassMIT
Web CloneJane-xiaoer/claude-skill-web-clone1k2 repos~2.7kAutomated safety check: PassMIT
Improve Threejsmillionco/react-doctor15k—~2.3kAutomated safety check: PassCustom licence
Typegpusoftware-mansion-labs/skills2912 repos~5.6kAutomated safety check: PassNone
3D Web Experiencesmadebyaris/advance-minimax-m3-cursor-rules126—~3kAutomated safety check: PassMIT

Similar skills

  • Polycss

    layoutit/polycss

    Build PolyCSS scenes that render 3D meshes, primitive shapes, or custom polygons as DOM/CSS polygon elements.

    759 GitHub stars~2.4k tokensUpdated 1 mo ago
    Game DevelopmentAuto-check passed
  • Web Clone

    Jane-xiaoer/claude-skill-web-clone

    网站复刻 / 克隆方法论。USE WHEN 用户说 复刻网站、克隆网站、clone website、抄个站、仿站、 照着这个站做一个、reproduce site、还原某个网页效果、把这个站搬下来改成我的、 复刻某个交互/WebGL/Canvas/Three.js 效果。提供「先拿真源码 → 判路径 → 逆向拆解 → 搭工程 → 替换内容」的可移植决策树,覆盖静态站 /…

    1k GitHub starsUsed in 2 repos~2.7k tokens
    Game DevelopmentAuto-check passed
  • Improve Threejs

    millionco/react-doctor

    Audit and fix Three.js and React Three Fiber apps for frame-loop performance, GPU memory leaks, scene-graph correctness, and visual defects like z-fighting, shadow acne, wrong color space, and…

    15k GitHub stars~2.3k tokensUpdated today
    Game DevelopmentAuto-check passed
  • Typegpu

    software-mansion-labs/skills

    TypeGPU is type-safe WebGPU in TypeScript. An agent skill from software-mansion-labs/skills.

    291 GitHub starsUsed in 2 repos~5.6k tokens
    Game DevelopmentAuto-check passed
  • 3D Web Experiences

    madebyaris/advance-minimax-m3-cursor-rules

    Builds 3D web scenes with Three.js and React Three Fiber, with attention to art direction, a performance budget, mobile behavior and fallbacks.

    126 GitHub stars~3k tokensUpdated 3 mo ago
    Game DevelopmentAuto-check passed
  • Pmndrs Viverse

    pmndrs/viverse

    Build, modify, debug, or publish VIVERSE-ready web games and 3D apps with Three.js, React Three Fiber, @pmndrs/viverse, @react-three/viverse, VIVERSE SDK integrations, character controllers…

    132 GitHub stars~1.7k tokensUpdated 6 days ago
    Game DevelopmentAuto-check passed

More from freshtechbro/claudedesignskills

All 19 skills in this repo
  • Anime.js Animation Guide

    freshtechbro/claudedesignskills

    Guides use of Anime.js for timeline sequences, stagger effects, SVG morphing and keyframe animation on DOM elements, CSS, SVG and JavaScript objects.

    994 GitHub stars~2.7k tokensUpdated 10 mo ago
    Auto-check passed
  • Barba.js Page Transitions

    freshtechbro/claudedesignskills

    Adds animated page transitions to multi-page sites with Barba.js, covering the wrapper and container markup, lifecycle hooks, views and GSAP integration.

    994 GitHub stars~4.9k tokensUpdated 10 mo ago
    Auto-check passed
  • Blender Web Export Pipeline

    freshtechbro/claudedesignskills

    Exports and optimizes Blender 3D models and animations for the web as glTF, covering batch Python scripting, texture baking, decimation and LOD generation for Three.js and Babylon.js.

    994 GitHub stars~4.2k tokensUpdated 10 mo ago
    Auto-check passed
  • GSAP and ScrollTrigger

    freshtechbro/claudedesignskills

    Covers GSAP tweens and timelines and the ScrollTrigger plugin for scroll-driven animation, including pinning, scrubbing, parallax and horizontal scroll sections.

    994 GitHub stars~4.3k tokensUpdated 10 mo ago
    Auto-check passed
  • Locomotive Scroll

    freshtechbro/claudedesignskills

    A guide to the Locomotive Scroll library for smooth scrolling, parallax, viewport detection, sticky elements and GSAP ScrollTrigger integration.

    994 GitHub stars~3.1k tokensUpdated 10 mo ago
    Auto-check passed
  • Lottie Animation Integration

    freshtechbro/claudedesignskills

    Implements After Effects Lottie animations in web and React apps: picking JSON or dotLottie format, a rendering library, and a data source, with an optimizer script.

    994 GitHub stars~4.5k tokensUpdated 10 mo ago
    Auto-check passed

Works with

Questions about Spline Interactive

What does Spline Interactive do?

Browser-based 3D design tool with visual editor, animation, and web export. Spline Interactive is an agent skill from freshtechbro/claudedesignskills. Browser-based 3D design tool with visual editor, animation, and web export.

When should I use Spline Interactive?

Spline Interactive fits situations like: creating 3D scenes without code; designing interactive web experiences; prototyping 3D UI; exporting to React/web.

How do I install Spline Interactive in Claude Code?

Run `npx skills add freshtechbro/claudedesignskills --skill spline-interactive -a claude-code`. Or copy the skill folder (.claude/skills/spline-interactive in freshtechbro/claudedesignskills) into .claude/skills/spline-interactive in your project. Claude Code loads it when a task matches its description.

How do I install Spline Interactive in Codex?

Run `npx skills add freshtechbro/claudedesignskills --skill spline-interactive -a codex`. Or copy the skill folder (.claude/skills/spline-interactive in freshtechbro/claudedesignskills) into .agents/skills/spline-interactive in your project. Codex loads it when a task matches its description.

Can I use Spline Interactive in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add freshtechbro/claudedesignskills --skill spline-interactive -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/spline-interactive, .gemini/skills/spline-interactive, .github/skills/spline-interactive and .opencode/skills/spline-interactive in your project.

What does Spline Interactive need to run?

Going by SKILL.md and its folder, Spline Interactive needs Python for the scripts in its folder and the command-line tools its instructions call (npm). Our summary lists: Python 3; Node.js.

Does Spline Interactive access the network?

SKILL.md names 5 domains. In commands or code: prod.spline.design; the agent is likely to contact it when it follows the instructions. As links in the text: spline.design, docs.spline.design, github.com and spline.community. This is read from the text; nothing was executed.

Is Spline Interactive safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Spline Interactive use?

Spline Interactive is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Spline Interactive use?

About 4.9k tokens (SKILL.md is roughly 20k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.3k tokens, read only when the agent opens those files.

What are the alternatives to Spline Interactive?

Skills that share tags, products or a category with Spline Interactive: Polycss (layoutit/polycss, 759 stars), Web Clone (Jane-xiaoer/claude-skill-web-clone, 1k stars), Improve Threejs (millionco/react-doctor, 15k stars) and Typegpu (software-mansion-labs/skills, 291 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Spline Interactive?

freshtechbro (a GitHub user) maintains it in freshtechbro/claudedesignskills, which has 994 GitHub stars. The repository holds 19 skills in this directory. The repository was last updated on November 20, 2025.

Source: freshtechbro/claudedesignskills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.