Skip to content

notque/vexjoy-agent / skills/frontend/frontend

frontend

Unverified

Frontend: UI design, distinctive visual styles, HTML artifacts, Three.js 3D, TypeScript/React/Next.js apps, e-commerce, portfolios, React Native, web performance.

FileKindSize
SKILL.mdskill md22.5 KB
SPEC.mdmarkdown4.3 KB
agents/html-builder.mdmarkdown5.9 KB
assets/base-template.htmlother495 B
references/design-refs/accessibility-review.mdmarkdown13.0 KB
references/design-refs/design-critique.mdmarkdown10.4 KB
references/design-refs/design-handoff.mdmarkdown9.9 KB
references/design-refs/design-systems.mdmarkdown9.3 KB
references/design-refs/llm-design-failure-modes.mdmarkdown9.1 KB
references/design-refs/ux-copy.mdmarkdown9.5 KB
references/distinctive-frontend-design-refs/animation-patterns.mdmarkdown10.5 KB
references/distinctive-frontend-design-refs/background-techniques.mdmarkdown10.5 KB
references/distinctive-frontend-design-refs/balatro-shader-breakdown.mdmarkdown14.9 KB
references/distinctive-frontend-design-refs/card-shader-patterns.mdmarkdown10.9 KB
references/distinctive-frontend-design-refs/color-inspirations.jsonconfig9.4 KB
references/distinctive-frontend-design-refs/css-audit-patterns.mdmarkdown4.7 KB
references/distinctive-frontend-design-refs/font-catalog.jsonconfig9.7 KB
references/distinctive-frontend-design-refs/game-ui-polish.mdmarkdown6.3 KB
references/distinctive-frontend-design-refs/honest-placeholders.mdmarkdown3.2 KB
references/distinctive-frontend-design-refs/implementation-examples.mdmarkdown7.7 KB
references/distinctive-frontend-design-refs/macrostructure-catalog.mdmarkdown9.3 KB
references/distinctive-frontend-design-refs/oklch-color-harmony.mdmarkdown7.3 KB
references/distinctive-frontend-design-refs/performance-budgets.mdmarkdown10.6 KB
references/distinctive-frontend-design-refs/phase-details.mdmarkdown4.8 KB
references/distinctive-frontend-design-refs/pptx-conversion.mdmarkdown9.7 KB
references/distinctive-frontend-design-refs/roll-text.mdmarkdown7.2 KB
references/distinctive-frontend-design-refs/shader-integration-react.mdmarkdown16.7 KB
references/distinctive-frontend-design-refs/slide-controller.mdmarkdown9.4 KB
references/distinctive-frontend-design-refs/text-animation-patterns.mdmarkdown4.3 KB
references/html-artifact-refs/design-system.mdmarkdown10.2 KB
references/html-artifact-refs/diagram-layering.mdmarkdown3.9 KB
references/html-artifact-refs/infographic-layouts.mdmarkdown4.9 KB
references/html-artifact-refs/pdf-export.mdmarkdown6.0 KB
references/html-artifact-refs/pptx-export.mdmarkdown10.2 KB
references/html-artifact-refs/shape-diagram-illustration.mdmarkdown4.3 KB
references/nextjs-ecommerce.mdmarkdown3.4 KB
references/nextjs-ecommerce/admin-dashboard.mdmarkdown9.8 KB
references/nextjs-ecommerce/error-catalog.mdmarkdown7.9 KB
references/nextjs-ecommerce/expertise.mdmarkdown5.1 KB
references/nextjs-ecommerce/patterns-and-errors.mdmarkdown4.6 KB
references/nextjs-ecommerce/preferred-patterns.mdmarkdown8.0 KB
references/nextjs-ecommerce/shopping-cart-patterns.mdmarkdown7.7 KB
references/nextjs-ecommerce/stripe-integration.mdmarkdown9.5 KB
references/performance-optimization.mdmarkdown9.9 KB
references/performance-optimization/browser-dom-optimizations.mdmarkdown6.0 KB
references/performance-optimization/bundle-optimization.mdmarkdown7.9 KB
references/performance-optimization/core-web-vitals.mdmarkdown9.6 KB
references/performance-optimization/js-algorithm-optimizations.mdmarkdown9.6 KB
references/performance-optimization/metrics-and-monitoring.mdmarkdown8.8 KB
references/performance-optimization/nextjs-optimization.mdmarkdown10.6 KB
references/performance-optimization/performance-testing.mdmarkdown9.6 KB
references/performance-optimization/preferred-patterns.mdmarkdown7.4 KB
references/performance-optimization/react-async-patterns.mdmarkdown7.0 KB
references/performance-optimization/react-bundle-optimization.mdmarkdown6.3 KB
references/performance-optimization/react-rendering-performance.mdmarkdown12.0 KB
references/react-native.mdmarkdown4.4 KB
references/react-native/animation-patterns.mdmarkdown3.9 KB
references/react-native/error-handling.mdmarkdown7.7 KB
references/react-native/list-performance.mdmarkdown5.4 KB
references/react-native/monorepo-config.mdmarkdown2.3 KB
references/react-native/navigation-patterns.mdmarkdown2.0 KB
references/react-native/rendering-patterns.mdmarkdown3.2 KB
references/react-native/state-management.mdmarkdown3.3 KB
references/react-native/testing.mdmarkdown6.2 KB
references/react-native/ui-patterns.mdmarkdown5.0 KB
references/react-portfolio.mdmarkdown7.7 KB
references/react-portfolio/gallery-patterns.mdmarkdown2.5 KB
references/react-portfolio/image-optimization.mdmarkdown3.4 KB
references/react-portfolio/lightbox-patterns.mdmarkdown6.1 KB
references/react-portfolio/nextjs-app-router.mdmarkdown4.9 KB
references/react-portfolio/performance.mdmarkdown3.9 KB
references/react-portfolio/portfolio-seo.mdmarkdown4.8 KB
references/react-portfolio/responsive-design.mdmarkdown3.3 KB
references/threejs-builder-refs/advanced-animation.mdmarkdown12.1 KB
references/threejs-builder-refs/advanced-topics.mdmarkdown11.0 KB
references/threejs-builder-refs/build-recipes.mdmarkdown7.4 KB
references/threejs-builder-refs/game-architecture.mdmarkdown10.4 KB
references/threejs-builder-refs/game-patterns.mdmarkdown12.5 KB
references/threejs-builder-refs/gltf-loading.mdmarkdown8.6 KB
references/threejs-builder-refs/performance-patterns.mdmarkdown11.8 KB
references/threejs-builder-refs/react-three-fiber.mdmarkdown17.8 KB
references/threejs-builder-refs/shader-patterns.mdmarkdown15.0 KB
references/threejs-builder-refs/visual-polish.mdmarkdown16.3 KB
references/threejs-builder-refs/webgpu.mdmarkdown20.4 KB
references/typescript-frontend.mdmarkdown5.3 KB
references/typescript-frontend/engineering-rules.mdmarkdown7.8 KB
references/typescript-frontend/nextjs-security.mdmarkdown2.6 KB
references/typescript-frontend/react-view-transitions.mdmarkdown5.4 KB
references/ui-design.mdmarkdown10.2 KB
references/ui-design/ai-slop-detection.mdmarkdown8.5 KB
references/ui-design/design-conventions.mdmarkdown2.8 KB
references/ui-design/motion-and-interaction.mdmarkdown5.6 KB
scripts-distinctive-frontend-design/css_slop_rules.pyscript15.3 KB
scripts-distinctive-frontend-design/tests/test_css_slop_rules.pyscript6.9 KB
scripts-distinctive-frontend-design/tests/test_validate_design_advisory.pyscript3.3 KB
scripts-distinctive-frontend-design/tests/test_validate_design_macro.pyscript4.3 KB
scripts-distinctive-frontend-design/validate_design.pyscript22.2 KB
scripts-html-artifact/assemble-template.pyscript7.5 KB
scripts-html-artifact/css_slop_rules.pyscript15.4 KB
scripts-html-artifact/detect-shape.pyscript7.0 KB
scripts-html-artifact/fill-template.pyscript5.5 KB
scripts-html-artifact/pptx-bridge/__init__.pyscript490 B
scripts-html-artifact/pptx-bridge/_pptx_engine.pyscript26.4 KB
scripts-html-artifact/pptx-bridge/extract_slides.pyscript13.5 KB
scripts-html-artifact/pptx-bridge/render_pptx.pyscript6.9 KB
scripts-html-artifact/pptx-bridge/run-unified.pyscript11.6 KB
scripts-html-artifact/render-github-issues.pyscript7.5 KB
scripts-html-artifact/tests/test_assemble_template.pyscript29.5 KB
scripts-html-artifact/tests/test_css_slop_emission.pyscript7.9 KB
scripts-html-artifact/tests/test_detect_shape.pyscript5.3 KB
scripts-html-artifact/tests/test_fill_template.pyscript5.2 KB
scripts-html-artifact/tests/test_to_pdf.pyscript13.3 KB
scripts-html-artifact/tests/test_validate_artifact.pyscript13.6 KB
scripts-html-artifact/to-pdf.pyscript12.5 KB
scripts-html-artifact/validate-artifact.pyscript11.0 KB
templates/base-reset.cssother1.2 KB
templates/components/collapsible.cssother1.1 KB
templates/components/collapsible.jsscript516 B
templates/components/copy-button.cssother534 B
templates/components/copy-button.jsscript334 B
templates/components/drag-drop.cssother612 B
templates/components/drag-drop.jsscript1.1 KB
templates/components/filter.cssother1.1 KB
templates/components/filter.jsscript987 B
templates/components/keyboard-nav.cssother249 B
templates/components/keyboard-nav.jsscript900 B
templates/components/scrollytelling.cssother1.5 KB
templates/components/scrollytelling.jsscript2.0 KB
templates/components/slider.cssother848 B
templates/components/tabs.cssother770 B
templates/components/tabs.jsscript508 B
templates/components/theme-toggle.cssother1.2 KB
templates/components/theme-toggle.jsscript178 B
templates/fonts/ArchivoBlack-OFL.txtmarkdown4.4 KB
templates/fonts/archivo-black.cssother13.7 KB
templates/print/code-review-print.cssother1.9 KB
templates/print/data-viz-print.cssother1.5 KB
templates/print/deck-print.cssother1.5 KB
templates/print/default-print.cssother1.6 KB
templates/print/diagram-print.cssother1.6 KB
templates/print/editor-print.cssother2.1 KB
templates/print/prototype-print.cssother1.4 KB
templates/print/report-print.cssother1.8 KB
templates/print/spec-print.cssother1.4 KB
templates/saved/README.mdmarkdown1.8 KB
templates/saved/business-review.htmlother17.1 KB
templates/saved/business-review.slots.jsonconfig1.5 KB
templates/saved/github-issues.htmlother34.0 KB
templates/saved/project-kickoff.htmlother17.3 KB
templates/saved/project-kickoff.slots.jsonconfig1.7 KB
templates/saved/system-design.htmlother16.9 KB
templates/saved/system-design.slots.jsonconfig1.6 KB
templates/shapes/code-review.cssother2.7 KB
templates/shapes/data-viz.cssother2.3 KB
templates/shapes/deck.cssother1.9 KB
templates/shapes/diagram.cssother2.7 KB
templates/shapes/editor.cssother2.8 KB
templates/shapes/prototype.cssother2.7 KB
templates/shapes/report.cssother2.9 KB
templates/shapes/spec.cssother3.0 KB
templates/themes/birchline.cssother2.4 KB
templates/themes/dark-focus.cssother2.6 KB
templates/themes/interactive-warm.cssother4.5 KB
templates/themes/minimal-document.cssother2.6 KB

references/distinctive-frontend-design-refs/card-shader-patterns.md

View on GitHub
# Card Shader Patterns

WebGL2 fragment shader patterns for card game visual effects. All shaders target `#version 300 es` (WebGL2). No texture lookups — all effects are procedural, running on any WebGL2-capable device without asset loading.

**Card aspect ratio**: 400×560 (5:7). UV coordinates are aspect-corrected where noted.

---

## Shader Architecture

Every card shader uses the same vertex shader. The fragment shader varies by effect tier.

### Shared Vertex Shader

```glsl
#version 300 es
precision highp float;

in vec2 a_position;  // clip-space quad: [-1,1] x [-1,1]
out vec2 v_uv;       // normalized [0,1] UV for the fragment shader

void main() {
  // Convert clip-space position to [0,1] UV
  v_uv = a_position * 0.5 + 0.5;
  gl_Position = vec4(a_position, 0.0, 1.0);
}
```

The vertex shader draws a full-screen quad covering the canvas. Two triangles, four vertices, no index buffer needed for a quad (use `TRIANGLE_STRIP`):

```typescript
// Quad geometry — reuse across all card canvases
const QUAD_VERTS = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
```

### Uniform Interface (all shaders)

```glsl
// Required uniforms — every shader must declare all of these
uniform float u_time;       // elapsed seconds, JS wraps at 1000.0 to avoid float precision loss
uniform float u_rarity;     // 0.0=common, 0.25=uncommon, 0.5=rare, 1.0=legendary
uniform float u_hover;      // 0.0 to 1.0, lerped toward target each frame
uniform vec2  u_mouse;      // card-space mouse [0,1], (0.5,0.5) when not hovering
uniform vec2  u_resolution; // canvas pixel size (width, height)
uniform float u_upgraded;   // 0.0 or 1.0
```

---

## Noise Functions

All procedural effects use these noise primitives. Include whichever you need at the top of each fragment shader.

### Value Noise (fast, slightly blocky — good for energy pulses)

```glsl
// Hash function — maps vec2 to pseudo-random float in [0,1]
float hash(vec2 p) {
  p = fract(p * vec2(127.1, 311.7));
  p += dot(p, p + 19.19);
  return fract(p.x * p.y);
}

// 2D value noise with bilinear interpolation
float valueNoise(vec2 p) {
  vec2 i = floor(p);
  vec2 f = fract(p);
  // Smooth interpolation (C2 continuity)
  vec2 u = f * f * (3.0 - 2.0 * f);

  return mix(
    mix(hash(i),           hash(i + vec2(1.0, 0.0)), u.x),
    mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0, 1.0)), u.x),
    u.y
  );
}
```

### Simplex-Style Noise (smoother, organic — best for foil shimmer)

```glsl
// Based on Ian McEwan / Stefan Gustavson's simplex noise, adapted for WebGL2
vec3 permute(vec3 x) {
  return mod(((x * 34.0) + 1.0) * x, 289.0);
}

float snoise(vec2 v) {
  const vec4 C = vec4(
    0.211324865405187,   // (3.0-sqrt(3.0))/6.0
    0.366025403784439,   // 0.5*(sqrt(3.0)-1.0)
   -0.577350269189626,   // -1.0 + 2.0 * C.x
    0.024390243902439    // 1.0 / 41.0
  );

  vec2 i  = floor(v + dot(v, C.yy));
  vec2 x0 = v - i + dot(i, C.xx);
  vec2 i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
  vec4 x12 = x0.xyxy + C.xxzz;
  x12.xy -= i1;
  i = mod(i, 289.0);

  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))
                 + i.x + vec3(0.0, i1.x, 1.0));

  vec3 m = max(0.5 - vec3(
    dot(x0, x0),
    dot(x12.xy, x12.xy),
    dot(x12.zw, x12.zw)
  ), 0.0);

  m = m * m;
  m = m * m;

  vec3 x = 2.0 * fract(p * C.www) - 1.0;
  vec3 h = abs(x) - 0.5;
  vec3 ox = floor(x + 0.5);
  vec3 a0 = x - ox;
  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);

  vec3 g;
  g.x  = a0.x  * x0.x   + h.x  * x0.y;
  g.yz = a0.yz * x12.xz + h.yz * x12.yw;

  return 130.0 * dot(m, g);
}
```

### Fractional Brownian Motion (layered noise for organic foil)

```glsl
// fBm: sum multiple noise octaves for more organic motion
// Use 3 octaves for shimmer (fast), 5 for legendary foil (higher quality)
float fbm(vec2 p, int octaves) {
  float value = 0.0;
  float amplitude = 0.5;
  float frequency = 1.0;
  float lacunarity = 2.0;
  float gain = 0.5;

  for (int i = 0; i < 8; i++) {
    if (i >= octaves) break;
    value += amplitude * snoise(p * frequency);
    frequency *= lacunarity;
    amplitude *= gain;
  }
  return value;
}
```

---

## Effect 1: Metallic Shimmer (uncommon)

A single bright band that sweeps diagonally across the card surface. Subtle — opacity capped at 0.3.

```glsl
#version 300 es
precision highp float;

in vec2 v_uv;
out vec4 fragColor;

uniform float u_time;
uniform float u_rarity;   // Expected: 0.25 for uncommon
uniform float u_hover;
uniform vec2  u_resolution;

void main() {
  vec2 uv = v_uv;

  // Diagonal shimmer band: project UV onto diagonal axis
  float diagAxis = uv.x * 0.6 + uv.y * 0.4;

  // Band position oscillates with time, hover accelerates it
  float speed = 0.4 + u_hover * 0.6;
  float bandPos = fract(diagAxis - u_time * speed);

  // Soft band: sharp center, falloff on edges
  float band = smoothstep(0.0, 0.08, bandPos) * smoothstep(0.22, 0.12, bandPos);

  // Silver/white color for metallic feel
  vec3 shimmerColor = vec3(0.85, 0.90, 1.0);

  // Opacity: base 0.15 idle, up to 0.30 on hover
  float opacity = (0.15 + u_hover * 0.15) * band;

  // Vignette: fade toward card edges so effect stays centered
  vec2 centered = uv - 0.5;
  float vignette = 1.0 - smoothstep(0.3, 0.5, length(centered));

  fragColor = vec4(shimmerColor, opacity * vignette);
}
```

---

## Effect 2: Rare Shimmer + Blue Hue Shift

Shimmer band plus a blue-purple hue overlay and edge glow. Intensity doubles on hover.

```glsl
#version 300 es
precision highp float;

in vec2 v_uv;
out vec4 fragColor;

uniform float u_time;
uniform float u_rarity;   // Expected: 0.5 for rare
uniform float u_hover;
uniform vec2  u_mouse;
uniform vec2  u_resolution;
uniform float u_upgraded;

// [Include valueNoise and snoise from above]

// HSV to RGB for color cycling
vec3 hsv2rgb(vec3 c) {
  vec4 K = vec4(1.0, 2.0/3.0, 1.0/3.0, 3.0);
  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}

void main() {
  vec2 uv = v_uv;

  // Aspect-correct UVs for 400x560 card (5:7 ratio)
  vec2 aspectUV = vec2(uv.x, uv.y * (560.0 / 400.0));

  // --- Shimmer band (same as uncommon, higher opacity) ---
  float diagAxis = uv.x * 0.6 + uv.y * 0.4;
  float speed = 0.5 + u_hover * 0.8;
  float bandPos = fract(diagAxis - u_time * speed);
  float band = smoothstep(0.0, 0.06, bandPos) * smoothstep(0.18, 0.10, bandPos);

  // --- Blue hue shift layer ---
  // Subtle noise distortion on the UV before hue lookup
  float noiseVal = valueNoise(aspectUV * 3.0 + vec2(u_time * 0.15, u_time * 0.1));
  float hue = 0.62 + noiseVal * 0.08;  // Blue range: 0.58–0.70
  float sat = 0.7 + u_hover * 0.2;
  float val = 0.5 + band * 0.4;
  vec3 hueColor = hsv2rgb(vec3(hue, sat, val));

  // --- Edge pulse ---
  // Glow along card edges, stronger on hover
  vec2 edge = min(uv, 1.0 - uv);
  float edgeDist = min(edge.x, edge.y);
  float edgePulse = 1.0 - smoothstep(0.0, 0.08, edgeDist);
  float pulseAnim = 0.5 + 0.5 * sin(u_time * 2.0 + uv.y * 4.0);
  vec3 edgeColor = vec3(0.3, 0.5, 1.0);  // Blue
  float edgeIntensity = edgePulse * pulseAnim * (0.3 + u_hover * 0.4);

  // --- Upgraded: slightly more intense, slight green tint on edge ---
  vec3 upgradeColor = mix(edgeColor, vec3(0.3, 1.0, 0.5), u_upgraded * 0.3);

  // --- Composite ---
  vec3 finalColor = mix(hueColor, upgradeColor, edgePulse * 0.4);
  float finalOpacity = (0.25 + u_hover * 0.25) * (band * 0.6 + edgeIntensity);

  // Vignette
  vec2 centered = uv - 0.5;
  float vignette = 1.0 - smoothstep(0.25, 0.5, length(centered));

  fragColor = vec4(finalColor, finalOpacity * vignette);
}
```

---

## Effect 3: Energy Pulse (rarity-colored radial)

Radial pulse from card center, color and intensity keyed to `u_rarity`. Used as an ambient idle effect, not dependent on hover.

```glsl
#version 300 es
precision highp float;

in vec2 v_uv;
out vec4 fragColor;

uniform float u_time;
uniform float u_rarity;
uniform float u_hover;
uniform vec2  u_resolution;

void main() {
  vec2 uv = v_uv;
  vec2 centered = uv - 0.5;

  // Aspect-correct distance for non-square cards (400x560)
  centered.y *= (400.0 / 560.0);
  float dist = length(centered);

  // Pulse ring emanates from center
  float pulseSpeed = 0.8 + u_rarity * 0.4;
  float pulse = fract(dist * 2.5 - u_time * pulseSpeed);
  float ring = smoothstep(0.0, 0.1, pulse) * smoothstep(0.3, 0.15, pulse);

  // Falloff: pulses fade as they move outward
  float falloff = 1.0 - smoothstep(0.0, 0.55, dist);

  // Rarity color: common=silver, uncommon=blue, rare=gold, legendary=rainbow
  vec3 rarityColor;
  if (u_rarity < 0.3) {
    rarityColor = vec3(0.6, 0.6, 0.7);  // Silver (uncommon)
  } else if (u_rarity < 0.6) {
    rarityColor = vec3(1.0, 0.72, 0.0);  // Gold (rare) — matches #FFB800
  } else {
    // Legendary: animate through rainbow
    float hue = fract(u_time * 0.15 + dist * 0.5);
    rarityColor = vec3(
      0.5 + 0.5 * cos(6.28318 * (hue + 0.0)),
      0.5 + 0.5 * cos(6.28318 * (hue + 0.333)),
      0.5 + 0.5 * cos(6.28318 * (hue + 0.667))
    );
  }

  float intensity = ring * falloff * (0.4 + u_hover * 0.3);
  fragColor = vec4(rarityColor, intensity);
}
```

---

## UV Coordinate Reference

The card aspect ratio is 400×560 (width × height). When computing effects that need to appear geometrically correct (circles, uniform bands):

```glsl
// Aspect correction: make UV space square for geometric effects
// Multiply y by (width/height) to normalize
vec2 aspectUV = vec2(v_uv.x, v_uv.y * (400.0 / 560.0));

// For distance calculations from center:
vec2 centered = v_uv - 0.5;
centered.y *= (400.0 / 560.0);  // Correct for aspect
float dist = length(centered);   // Now a circle, not an ellipse
```

---

## Patterns to Detect and Fix

**Allocating arrays or objects in the fragment shader loop**: GLSL `for` loops with dynamic bounds or large local arrays cause driver stalls. Use a fixed iteration count (e.g., `for (int i = 0; i < 5; i++)`) and use `break` only when the loop count is truly constant.

**Using `gl_FragCoord` for UV**: Derive UVs from `v_uv` (passed from vertex shader), not `gl_FragCoord / u_resolution`. The varyings are more stable and the math is cleaner.

**Sampling `u_time` directly at full speed**: `u_time` increments at 1.0 per second by default. For slow organic movement, multiply by 0.3–0.6. For pulse timing, use `fract()` to loop cleanly instead of `mod()`.

**Opacity above 0.75 for shimmer effects**: Effects above 0.75 opacity obscure the card art and text. Test with `mix-blend-mode: screen` — the effective visual opacity is lower than the alpha value suggests.

**Using WebGL1 (`gl.getContext('webgl')`)**: Always request `webgl2`. WebGL1 lacks `#version 300 es`, `out vec4` fragment outputs, and the `in`/`out` varying syntax. Feature-detect and fall back to CSS if WebGL2 is unavailable.

**Declaring unused uniforms**: GLSL compilers strip uniforms that are declared but never referenced. The JS side calling `gl.getUniformLocation()` on a stripped uniform returns `null`, causing a silent no-op. Either reference every uniform in shader code or remove unused declarations.
brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).Stars: 322kUpdated Claude CodeCodexVerifiedInstall
brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).Stars: 198kUpdated Claude CodeCodexVerifiedInstall