Si alguna vez has abierto webs ganadoras del festival Awwwards o páginas promocionales interactivas de productos de Apple, seguro que te quedaste hipnotizado: objetos volumétricos luminosos que se balancean suavemente siguiendo el cursor del ratón, luz que se refracta a través de un cristal esmerilado y partículas que salen volando en un torbellino cinematográfico al hacer scroll.
Pero si llegaste a abrir el código fuente de esas páginas, la admiración se convertía rápido en un sudor frío. Los gráficos tridimensionales en la web basados en la librería Three.js y shaders de bajo nivel GLSL (OpenGL Shading Language) forman una de las áreas más duras del frontend. Aquí hace falta ser al mismo tiempo artista, matemático que domine matrices de transformación y programador capaz de vigilar a mano las fugas de memoria de la GPU.
La llegada del agente de terminal Claude Code CLI de Anthropic ha puesto patas arriba todo este flujo de trabajo. A diferencia de los chatbots normales que escupen trozos de código en un cuadro de texto, Claude Code vive dentro de tu propia terminal. Ve el árbol de archivos, instala paquetes con npm, compila shaders y corrige sobre la marcha los errores de renderizado de WebGL. Repasemos la receta paso a paso para montar una escena 3D interactiva con ayuda agéntica.
Arquitectura del flujo: por qué el agente domina el 3D mejor que muchos humanos
¿Por qué copiar y pegar desde la interfaz web de una red neuronal hacia Three.js acaba casi siempre en una pantalla negra? Porque el renderizado 3D exige una sincronía milimétrica entre varias capas a la vez:
- Inicialización del lienzo Canvas y del renderizador
WebGLRenderer; - Ajuste de proporciones de la cámara perspectiva (
PerspectiveCamera) y de la matriz de proyección al redimensionar la ventana; - Bucle de redibujado
requestAnimationFrame; - Creación de geometrías, materiales físicos y fuentes de luz;
- Y compilación de shaders de fragmento externos mediante plugins del empaquetador.
Si te saltas una sola línea, la escena simplemente no se renderiza y ni siquiera suelta un error en consola. El agente de terminal asume toda esa carga mecánica. Inicializa por sí solo un proyecto limpio con Vite, configura el empaquetador y enlaza los módulos paso a paso en un sistema coherente.
Flujo práctico: de una terminal vacía a un nudo flotante
Recorramos el camino en cinco minutos. Lo único que necesitas de partida es tener instalado Node.js 18+ y el paquete global Claude Code CLI.
Lo primero es levantar el proyecto e instalar las dependencias:
# Creamos el proyecto con Vite e instalamos Three.js
npm create vite@latest 3d-interactive-showcase -- --template vanilla
cd 3d-interactive-showcase
npm install three
claude
Dentro de la sesión de Claude Code no picamos código a mano. Formulamos la especificación arquitectónica en lenguaje natural: «Diseña una escena 3D interactiva en main.js: un nudo toroidal central flotante (TorusKnot) que reaccione con efecto de inercia suave (LERP 0.05) al movimiento del cursor del ratón, un sistema de dos mil partículas luminosas y adaptación dinámica al cambio de tamaño de la ventana del navegador».
El agente analiza la petición y crea una estructura equilibrada en main.js. Fíjate con qué elegancia resuelve el suavizado del movimiento:
import * as THREE from 'three';
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
camera.position.z = 5;
const renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
renderer.setSize(window.innerWidth, window.innerHeight);
renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
document.body.appendChild(renderer.domElement);
const geometry = new THREE.TorusKnotGeometry(1.2, 0.35, 128, 32);
const material = new THREE.MeshStandardMaterial({
color: 0x6366f1,
roughness: 0.2,
metalness: 0.8
});
const torusKnot = new THREE.Mesh(geometry, material);
scene.add(torusKnot);
const pointLight = new THREE.PointLight(0xffffff, 2, 50);
pointLight.position.set(5, 5, 5);
scene.add(pointLight, new THREE.AmbientLight(0x222233, 1.5));
let mouseX = 0, mouseY = 0;
let targetX = 0, targetY = 0;
window.addEventListener('mousemove', (event) => {
mouseX = (event.clientX / window.innerWidth - 0.5) * 2;
mouseY = (event.clientY / window.innerHeight - 0.5) * 2;
});
function animate() {
requestAnimationFrame(animate);
// Interpolación suave de coordenadas (LERP)
targetX += (mouseX - targetX) * 0.05;
targetY += (mouseY - targetY) * 0.05;
torusKnot.rotation.y = targetX * 1.5;
torusKnot.rotation.x = targetY * 1.5;
torusKnot.rotation.z += 0.005;
renderer.render(scene, camera);
}
animate();
window.addEventListener('resize', () => {
camera.aspect = window.innerWidth / window.innerHeight;
camera.updateProjectionMatrix();
renderer.setSize(window.innerWidth, window.innerHeight);
});
Generación de shaders personalizados: efecto de brillo Fresnel
Si los materiales estándar de Three.js se quedan cortos y buscas un efecto de autor (por ejemplo, un resplandor de neón por el contorno del objeto), el agente conecta shaders GLSL a medida.
En lugar de pasarte horas estudiando fórmulas matemáticas, le pides a Claude: «Añade un efecto de shader de brillo Fresnel con pulsación temporal». El modelo diseña el shader de fragmento:
uniform float uTime;
varying vec2 vUv;
varying vec3 vNormal;
void main() {
vec3 normal = normalize(vNormal);
float pulse = sin(uTime * 2.0) * 0.5 + 0.5;
float fresnel = pow(1.0 - dot(normal, vec3(0.0, 0.0, 1.0)), 2.0);
vec3 glowColor = mix(vec3(0.2, 0.4, 1.0), vec3(0.9, 0.2, 0.8), pulse);
gl_FragColor = vec4(glowColor * (fresnel + 0.3), 1.0);
}
Claude Code edita automáticamente el archivo de configuración del empaquetador vite.config.js para habilitar la importación de extensiones .glsl y enlaza la fórmula con las variables de tiempo uTime.
Trampas de WebGL: batería del móvil y fugas de memoria de vídeo
En el desarrollo de interfaces 3D hay dos hoyos peligrosos en los que los principiantes caen una y otra vez.
El primero es la voracidad de recursos. Si en una pantalla de móvil con alta densidad de píxeles (Retina 3x) lanzas el renderizado a resolución nativa con antialiasing activado, la tasa de fotogramas caerá a 15 FPS y la batería se derretirá ante tus ojos. Fíjate en la línea renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2)): limitar artificialmente la densidad de píxeles a 2 salva a los dispositivos móviles del sobrecalentamiento.
La segunda trampa son las fugas de memoria (Memory Leaks). En JavaScript normal el recolector de basura elimina automáticamente las variables sin uso. Pero en WebGL las geometrías y texturas se cargan directamente en la memoria de la tarjeta gráfica. Si simplemente quitas un objeto de la escena con scene.remove(mesh), la malla desaparece de la pantalla, pero sigue ocupando espacio en la VRAM. Con cada cambio de pestaña se irá fugando memoria hasta que el navegador reviente con un error de WebGL Context Lost. Claude Code está entrenado en las reglas de limpieza y, al destruir componentes, invoca obligatoriamente geometry.dispose() y material.dispose().
Combinar Three.js con un agente de terminal acorta la distancia entre una idea de diseño atrevida y código funcional a cuestión de minutos. Ya no hace falta ser un gurú del álgebra lineal para sorprender a los usuarios con gráficos vivos de cine.

