lookbkdev/lookbk-skills / skills/laser-etch-hero
laser-etch-hero
VerifiedBuild a website hero where a laser engraver cuts the headline into a real plate - a vector contour pass, then a gantry raster line by line or a galvo hatching glyph by glyph - and one low raking lamp shows the cut's depth: char, smoke and a glowing front on maple, sparks and frosted metal on black anodised aluminium, or a pale frost on slate; the pointer moves the lamp. Two art-directed layouts: a maple board on a bench with the copy on a clamp bar (centred lockup), or a full-bleed anodised plate with the headline across the width (type as the effect). One self-contained HTML page plus a paste-in embed on the Motion Heroes kit v2, checked at four widths for text size, contrast and clearance, with a baked still picture if WebGL fails and a frame-exact looping 1080p MP4 that opens on the settled plate. Use for makers, engravers, workshops, tools, instruments, gifts or any product that is made, marked or personalised.
| File | Kind | Size |
|---|---|---|
| NOTICE.md | markdown | 1.1 KB |
| SKILL.md | skill md | 8.3 KB |
| TESTED.json | config | 975 B |
| assets/anodised.webp | binary | 948 B |
| assets/maple.webp | binary | 30.2 KB |
| assets/slate.webp | binary | 7.6 KB |
| examples/varde/hero.json | config | 1.3 KB |
| examples/wrenfold/hero.json | config | 1.3 KB |
| scripts/build.mjs | script | 263 B |
| scripts/check.mjs | script | 179 B |
| scripts/chrome.mjs | script | 3.6 KB |
| scripts/color.mjs | script | 1.4 KB |
| scripts/effect/effect.js | script | 43.8 KB |
| scripts/effect/effect.mjs | script | 5.5 KB |
| scripts/inline.mjs | script | 1.7 KB |
| scripts/kit/KIT.md | markdown | 13.7 KB |
| scripts/kit/build.mjs | script | 47.4 KB |
| scripts/kit/cdp.mjs | script | 5.1 KB |
| scripts/kit/check.mjs | script | 15.7 KB |
| scripts/kit/fonts.json | config | 5.4 KB |
| scripts/kit/record.mjs | script | 8.1 KB |
| scripts/kit/runtime.js | script | 22.5 KB |
| scripts/kit/shell.css | other | 18.7 KB |
| scripts/kit/three.json | config | 6.3 KB |
| scripts/markup.mjs | script | 6.2 KB |
| scripts/record.mjs | script | 255 B |
| scripts/screenshot.mjs | script | 1.8 KB |
scripts/kit/runtime.js
View on GitHub// Motion Heroes kit v2: the browser runtime. The build inlines this file into
// the page, followed by the effect, and calls MotionHeroRun(effect, id).
//
// It owns everything that isn't the picture itself:
// - the clock. The effect is drawn as a pure function of time, seek(t), so
// the same t always gives the same frame and a recording can step it.
// - pausing when the hero is off-screen or the tab is hidden,
// - the device pixel ratio (capped at 2, lowered on slow machines),
// - prefers-reduced-motion: one still frame, no loop,
// - the fallback: a still picture (SVG) shows until the first frame is
// drawn, and stays if WebGL, the CDN or the effect fails. Never a blank hero.
// - the layout's measurements for the effect: its field (view.stage), the
// bar, the plates and the headline's lines (view.type), so it can set the
// headline in the scene, light it (ctx.light) or pass in front of it (ctx.front),
// - fitting the headline to the width (the type-effect composition),
// - the pointer, smoothed, or on a slow made-up path when recording,
// - an effect's story (cfg.story): the scene played as 0–1 progress, by the
// clock (drive "time") or by the visitor scrolling through the section,
// pinned for a few screen heights (drive "scroll"; a recording scrolls
// the page itself on a scripted path, so it is the same on every machine),
// - window.MotionHero, which scripts/record.mjs drives frame by frame.
function MotionHeroRun(effect, id) {
const root = document.getElementById(id)
if (!root) return
const cfg = JSON.parse(document.getElementById(id + '-config').textContent)
const recording = /[?&]mh-record\b/.test(location.search)
const reducedQuery = matchMedia('(prefers-reduced-motion: reduce)')
let reduced = reducedQuery.matches && !recording
const canvas = root.querySelector('.mh-canvas')
const front = root.querySelector('.mh-front')
const bar = root.querySelector('.mh-bar')
const field = root.querySelector('.mh-field')
const title = root.querySelector('.mh-title')
const comp = cfg.composition
const steps = [...root.querySelectorAll('.mh-step')]
const story = cfg.story || null
const speed = cfg.motion.speed
const MAX_DPR = 2
let dprCap = MAX_DPR
let view = null
let started = false
let failed = false
let raf = 0
let last = null
let time = 0 // real seconds the hero has been on screen
let inView = true
const pointer = { x: 0, y: 0 }
const smooth = { x: 0, y: 0 }
let slow = 0
let frames = 0
let resolveReady
// the story, when the effect has one: progress 0–1 (sp smoothed toward target)
let pin = null
let target = 0
let sp = 0
const ready = new Promise((r) => (resolveReady = r))
root.classList.add('mh-live')
if (recording) root.classList.add('mh-record')
const ease = (x) => 1 - Math.pow(1 - Math.min(Math.max(x, 0), 1), 3)
// The pointer path used in recordings: a slow figure, starting at rest.
const path = (t) => {
const k = ease(t / 1.8)
return { x: (Math.sin(t * 0.7) * 0.55 + 0.18) * k, y: Math.sin(t * 1.13 + 0.6) * 0.38 * k }
}
const rel = (r, o) => ({ x: r.left - o.left, y: r.top - o.top, w: r.width, h: r.height })
/** The headline's lines, as laid out: boxes, baselines and the font, in hero pixels. */
function measureType(o) {
// a turned headline (data-rot) is measured upright about its centre; view.type.rotate says how to turn it back
const rot = root.dataset.rot === '1'
const keep = title.style.transform
if (rot) title.style.transform = 'translate(-50%, -50%)'
const t = measureLines(o)
if (rot) {
title.style.transform = keep
t.rotate = -Math.PI / 2
t.center = { x: t.box.x + t.box.w / 2, y: t.box.y + t.box.h / 2 }
const w = t.box.w
t.box = { x: t.center.x - t.box.h / 2, y: t.center.y - w / 2, w: t.box.h, h: w }
}
return t
}
function measureLines(o) {
const cs = getComputedStyle(title)
const size = parseFloat(cs.fontSize)
const ls = cs.letterSpacing === 'normal' ? 0 : parseFloat(cs.letterSpacing) || 0
// each word where the browser set it; words on the same baseline make a line
const g = document.createElement('canvas').getContext('2d')
g.font = `${cs.fontWeight} ${size}px ${cs.fontFamily}`
const m = g.measureText('Hg')
const fa = m.fontBoundingBoxAscent ?? size * 0.9
const fd = m.fontBoundingBoxDescent ?? size * 0.25
const words = [...title.querySelectorAll('.mh-part')].map((p) => {
const r = document.createRange()
r.selectNodeContents(p)
const b = r.getBoundingClientRect()
return { text: p.textContent, x: b.left - o.left, y: b.top - o.top, w: b.width, h: b.height, baseline: b.top - o.top + (b.height * fa) / (fa + fd), italic: getComputedStyle(p).fontStyle !== 'normal' }
})
const lines = []
for (const wd of words) {
let line = lines.find((l) => Math.abs(l.baseline - wd.baseline) < size * 0.3)
if (!line) lines.push((line = { parts: [], baseline: wd.baseline }))
line.parts.push({ text: wd.text, x: wd.x, w: wd.w, italic: wd.italic, y: wd.y, h: wd.h })
}
for (const l of lines) {
l.parts.sort((a, b) => a.x - b.x)
l.x = Math.min(...l.parts.map((p) => p.x))
l.w = Math.max(...l.parts.map((p) => p.x + p.w)) - l.x
l.y = Math.min(...l.parts.map((p) => p.y))
l.h = Math.max(...l.parts.map((p) => p.y + p.h)) - l.y
l.text = l.parts.map((p) => p.text).join(' ')
}
lines.sort((a, b) => a.baseline - b.baseline)
const font = (italic) => `${italic ? 'italic ' : ''}${cs.fontWeight} ${size}px ${cs.fontFamily}`
return { lines, size, letterSpacing: ls, family: cs.fontFamily, weight: cs.fontWeight, font, box: rel(title.getBoundingClientRect(), o), align: cs.textAlign, rotate: 0, center: null }
}
// the letters' real ink box (cap top to descender), as shares of the font size
function glyphMetrics(cs, lines) {
const g = document.createElement('canvas').getContext('2d')
g.font = `${cs.fontStyle} ${cs.fontWeight} 100px ${cs.fontFamily}`
let asc = 0
let desc = 0
let fa = 0
let fd = 0
for (const t of lines) {
const m = g.measureText(t)
asc = Math.max(asc, m.actualBoundingBoxAscent / 100)
desc = Math.max(desc, m.actualBoundingBoxDescent / 100)
fa = Math.max(fa, (m.fontBoundingBoxAscent ?? m.actualBoundingBoxAscent) / 100)
fd = Math.max(fd, (m.fontBoundingBoxDescent ?? m.actualBoundingBoxDescent) / 100)
}
return { asc, desc, fa, fd }
}
// type-effect: each line of the headline fitted to the width (never under
// 7.2% of the height), its line box trimmed to the capitals so the 40px
// under the bar is measured from the tops of the letters. On a portrait
// screen the word turns to run up the screen (data-rot), which sets it far
// larger than across a phone's width. lockup: the headline fitted to 85% of
// the width, at most 20% of the height.
function fit() {
if (comp !== 'type-effect' && comp !== 'lockup') return
root.style.removeProperty('--mh-fit')
root.style.removeProperty('--mh-band')
delete root.dataset.rot
root.removeAttribute('data-clip-ok')
title.style.lineHeight = ''
title.style.margin = ''
title.style.fontSize = '100px'
let widest = 1
const texts = []
for (const line of title.querySelectorAll('.mh-line')) {
const r = document.createRange()
r.selectNodeContents(line)
widest = Math.max(widest, r.getBoundingClientRect().width)
texts.push(line.textContent)
}
title.style.fontSize = ''
const cs = getComputedStyle(title)
const W = root.clientWidth
const H = root.clientHeight
const vh = innerHeight
const n = texts.length
const copy = root.querySelector('.mh-copy')
const copyH = copy ? copy.offsetHeight : 0
const barH = bar.offsetHeight
if (comp === 'lockup') {
if (W < 760) {
// phones: the lines wrap; the longest word is fitted to 92% of the width
title.style.fontSize = '100px'
let word = 1
for (const p of title.querySelectorAll('.mh-part')) {
const r = document.createRange()
r.selectNodeContents(p)
word = Math.max(word, r.getBoundingClientRect().width)
}
title.style.fontSize = ''
const size = Math.max(0.072 * vh, Math.min((100 * W * 0.92) / word, 0.24 * vh))
root.style.setProperty('--mh-fit', size.toFixed(2) + 'px')
return
}
const room = (H - barH - copyH - 2 * 40 - 36) / (n * 0.86)
const size = Math.max(0.072 * vh, Math.min((100 * W * 0.8) / widest, 0.25 * vh, room))
root.style.setProperty('--mh-fit', size.toFixed(2) + 'px')
return
}
const { asc, desc, fa, fd } = glyphMetrics(cs, texts)
const lh = (asc + desc) * 1.04
const pad = parseFloat(cs.paddingLeft) + parseFloat(cs.paddingRight)
const across = (100 * (W - pad)) / widest
// portrait: the word runs up the screen, in a band a screen tall (the copy follows below)
if (W / vh < 0.8) {
const band = vh - barH - 2 * 40
const along = (100 * (band - 8)) / widest
const thick = (W - 32) / (n * lh)
const up = Math.min(along, thick)
if (up > across * 1.15) {
root.dataset.rot = '1'
// the turned word's glyphs may reach past the sides of its line box: the section clips them, on purpose
root.setAttribute('data-clip-ok', '')
root.style.setProperty('--mh-band', band.toFixed(0) + 'px')
root.style.setProperty('--mh-fit', Math.max(0.072 * vh, up).toFixed(2) + 'px')
title.style.lineHeight = lh.toFixed(4)
return
}
}
const room = (H - barH - copyH - 2 * 40 - 8) / (n * lh)
const size = Math.max(0.072 * vh, Math.min(across, room))
// where the capitals start inside the trimmed line box
const shift = ((fa - fd - asc + desc) / 2 - (lh - asc - desc) / 2) * size
root.style.setProperty('--mh-fit', size.toFixed(2) + 'px')
title.style.lineHeight = lh.toFixed(4)
title.style.margin = `${(-shift).toFixed(1)}px 0 ${shift.toFixed(1)}px`
}
/** The layout, measured: the effect's field (the stage), the bar, the plates and the headline. */
function measure() {
fit()
const o = root.getBoundingClientRect()
const W = root.clientWidth
const H = root.clientHeight
const stage = rel(field.getBoundingClientRect(), o)
const plates = [...root.querySelectorAll('.mh-plate')].filter((p) => p.offsetWidth).map((p) => rel(p.getBoundingClientRect(), o))
const dpr = Math.min(window.devicePixelRatio || 1, dprCap)
const mobile = W < 760
return { width: W, height: H, dpr, stage, mobile, stacked: mobile, composition: comp, typeMode: cfg.typeMode, bar: rel(bar.getBoundingClientRect(), o), plates, type: measureType(o) }
}
// ctx.light(x, y, r): where the effect's light falls (hero pixels), so the
// headline (typeMode "lit") brightens there too; ctx.light(null) turns it off.
function light(x, y, r) {
if (x === null || x === undefined || !view) {
title.style.setProperty('--mh-lr', '1px')
title.style.setProperty('--mh-lx', '-9999px')
return
}
const b = view.type.box
title.style.setProperty('--mh-lx', (x - b.x).toFixed(1) + 'px')
title.style.setProperty('--mh-ly', (y - b.y).toFixed(1) + 'px')
title.style.setProperty('--mh-lr', Math.max(1, r).toFixed(1) + 'px')
}
/* ---- the story ---- */
const clamp01 = (x) => Math.min(Math.max(x, 0), 1)
const smoothstep = (x) => ((x = clamp01(x)), x * x * (3 - 2 * x))
// The scripted scroll of a recording (and the reduced-motion still of a
// scroll story): rest for `lead`, glide through the story, rest. Real
// seconds in, progress out. The effect may give its own: script(seconds, story).
function script(seconds) {
if (effect.script) {
try {
return clamp01(Number(effect.script(seconds, story)) || 0)
} catch (e) {
console.warn('[motion hero] script():', e)
}
}
return smoothstep((seconds * speed - story.lead) / story.length)
}
// drive "time": the clock (scene seconds) → progress, looping after `hold`
function timed(seconds) {
let c = seconds * speed
if (story.loop) {
const period = story.lead + story.length + story.hold
c = ((c % period) + period) % period
}
return clamp01((c - story.lead) / story.length)
}
// drive "scroll": wrap the section in a box `pin` screen heights taller
// and make it sticky, so it holds still while the page scrolls past.
function setupPin() {
const wrap = document.createElement('div')
wrap.className = 'mh-pin'
wrap.style.position = 'relative'
root.parentNode.insertBefore(wrap, root)
wrap.appendChild(root)
root.style.position = 'sticky'
const p = {
wrap,
layout() {
const vh = innerHeight
const rh = root.offsetHeight
root.style.top = Math.min(0, vh - rh) + 'px'
wrap.style.height = Math.round(rh + story.pin * vh) + 'px'
p.read()
},
// scroll position → progress (exact: no smoothing here)
read() {
const vh = innerHeight
const pre = Math.max(0, root.offsetHeight - vh)
target = clamp01((-wrap.getBoundingClientRect().top - pre) / (story.pin * vh))
return target
},
// the page scroll at which progress is `k`
scrollFor(k) {
const vh = innerHeight
const pre = Math.max(0, root.offsetHeight - vh)
return wrap.getBoundingClientRect().top + scrollY + pre + k * story.pin * vh
},
}
addEventListener('scroll', () => p.read(), { passive: true })
addEventListener('resize', () => p.layout())
p.layout()
return p
}
/** The progress of the frame on screen (0 without a story). */
function progressNow() {
if (!story) return 0
return reduced ? progressAt(cfg.stillTime, true) : progressAt(time)
}
/** Progress 0–1 for the frame at real seconds t. */
function progressAt(t, still) {
if (story.drive === 'scroll') return pin && !still ? sp : script(t)
return still ? clamp01((t * speed - story.lead) / story.length) : timed(t)
}
// Places the still picture's object: where the effect says (its optional
// place(view, params), which must not need init), or the stage's middle.
function place(v) {
const s = v.stage
let at = { x: s.x + s.w / 2, y: s.y + s.h / 2, size: Math.min(s.w, s.h) * (cfg.stillScale || 0.8) }
try {
if (effect.place) at = effect.place(v, cfg.params) || at
} catch (e) {
console.warn('[motion hero] place():', e)
}
root.style.setProperty('--mh-sx', at.x + 'px')
root.style.setProperty('--mh-sy', at.y + 'px')
root.style.setProperty('--mh-ss', at.size + 'px')
}
function fail(err) {
if (failed) return
failed = true
cancelAnimationFrame(raf)
root.classList.remove('mh-ready')
root.classList.add('mh-fallback')
const reason = String((err && err.message) || err)
console.warn('[motion hero] showing the still picture:', reason)
resolveReady({ ok: false, reason })
}
function draw(t, still) {
try {
const state = { pointer: still ? { x: 0, y: 0 } : smooth, time: t, still: !!still }
if (!story) effect.seek(t * speed, state)
else {
// with a story, seek gets story time: progress × length
state.progress = progressAt(t, still)
state.drive = story.drive
root.style.setProperty('--mh-p', state.progress.toFixed(3))
effect.seek(state.progress * story.length, state)
}
if (steps.length) {
const k = Math.min(steps.length - 1, Math.floor((state.progress || 0) * steps.length * 0.999 + (still ? 0 : 0)))
steps.forEach((li, i) => li.classList.toggle('mh-on', i === k))
}
if (!root.classList.contains('mh-ready')) root.classList.add('mh-ready')
} catch (e) {
fail(e)
}
}
function resize() {
if (pin) pin.layout()
if (!started || failed) {
place(measure())
return
}
view = measure()
place(view)
try {
effect.resize(view)
} catch (e) {
return fail(e)
}
if (reduced) draw(cfg.stillTime, true)
else if (!raf && !recording) draw(time)
}
function tick(now) {
raf = 0
if (failed || reduced || recording) return
if (!inView || document.hidden) {
last = null
return // the observers start it again
}
raf = requestAnimationFrame(tick)
const dt = last === null ? 0 : Math.min((now - last) / 1000, 0.1)
last = now
time += dt
const k = 1 - Math.exp(-dt * 5)
const aim = cfg.motion.pointer ? pointer : { x: 0, y: 0 }
smooth.x += (aim.x - smooth.x) * k
smooth.y += (aim.y - smooth.y) * k
if (pin) {
sp += (target - sp) * (1 - Math.exp(-dt * 9))
if (Math.abs(target - sp) < 0.0005) sp = target
}
draw(time)
// Slow machine: draw fewer pixels rather than drop frames.
if (dt > 0) {
frames++
if (dt > 1 / 40) slow++
if (frames >= 60) {
if (slow > 30 && dprCap > 1) {
dprCap = Math.max(1, dprCap - 0.5)
resize()
}
frames = 0
slow = 0
}
}
}
const run = () => {
if (!raf && started && !failed && !reduced && !recording) raf = requestAnimationFrame(tick)
}
function hasWebGL() {
try {
const c = document.createElement('canvas')
const gl = c.getContext('webgl2') || c.getContext('webgl')
if (!gl) return false
const lose = gl.getExtension('WEBGL_lose_context')
if (lose) lose.loseContext()
return true
} catch {
return false
}
}
async function start() {
// the headline is measured (and fitted) with its real font
if (document.fonts && document.fonts.ready) await Promise.race([document.fonts.ready, new Promise((r) => setTimeout(r, 3000))])
view = measure()
place(view)
if (cfg.needs === 'webgl' && !hasWebGL()) return fail(new Error('WebGL is not available'))
const ctx = {
root,
canvas,
front,
composition: comp,
typeMode: cfg.typeMode,
light,
/** A file the effect ships (effect.mjs assets), as a URL next to the page. */
asset: (name) => {
if (!cfg.assets || !cfg.assets[name]) throw new Error('unknown asset ' + name)
return new URL(cfg.assets[name], document.baseURI).href
},
params: cfg.params,
theme: cfg.theme,
recording,
reduced,
view,
load: (name) => {
if (cfg.libs[name]) return import(cfg.libs[name])
// three.js add-ons through the import map (declared in effect.mjs addons, so they carry SRI)
if (cfg.three && name.startsWith('three/addons/')) {
if (!cfg.three.addons.includes(name.slice(13))) throw new Error(name + ' is not in the effect\'s addons')
return import(name)
}
throw new Error('unknown library ' + name)
},
// An effect's own controls (a finish picker, say) call this so a
// reduced-motion page still redraws when they're used.
redraw: () => {
if (reduced) draw(cfg.stillTime, true)
},
now: () => (reduced ? cfg.stillTime : time) * speed,
story,
/** The story's progress now (0–1); 0 without a story. */
progress: () => progressNow(),
}
let timer
const timeout = new Promise((_, no) => {
timer = setTimeout(() => no(new Error('the effect took too long to load')), recording ? 45000 : 12000)
})
try {
await Promise.race([effect.init(ctx), timeout])
} catch (e) {
return fail(e)
} finally {
clearTimeout(timer)
}
started = true
view = measure()
place(view)
try {
effect.resize(view)
} catch (e) {
return fail(e)
}
if (reduced) draw(cfg.stillTime, true)
else draw(recording ? 0 : time)
if (!failed) resolveReady({ ok: true })
run()
}
// pin first, before the copy's intro starts; not in reduced motion (the page scrolls normally)
if (story && story.drive === 'scroll' && !reduced) pin = setupPin()
addEventListener('pointermove', (e) => {
if (recording) return
const r = root.getBoundingClientRect()
pointer.x = Math.max(-1, Math.min(1, ((e.clientX - r.left) / r.width) * 2 - 1))
pointer.y = Math.max(-1, Math.min(1, -(((e.clientY - r.top) / r.height) * 2 - 1)))
})
new ResizeObserver(() => resize()).observe(root)
if ('IntersectionObserver' in window)
new IntersectionObserver((es) => {
inView = es[es.length - 1].isIntersecting
run()
}).observe(root)
document.addEventListener('visibilitychange', run)
reducedQuery.addEventListener?.('change', (e) => {
reduced = e.matches && !recording
if (reduced) {
cancelAnimationFrame(raf)
raf = 0
if (started && !failed) draw(cfg.stillTime, true)
} else run()
})
// Driven by scripts/record.mjs: seek(seconds) draws that moment of the
// intro and the effect, and resolves once it is on screen.
const api = {
ready,
posterTime: cfg.posterTime,
stillTime: cfg.stillTime,
/** The effect's story ({ drive, pin, length, lead, hold, loop }) or null. */
story,
/** Real seconds until a recording reaches the end of the story (lead + length, at motion.speed). */
storySeconds: story ? (story.lead + story.length) / speed : 0,
/** The story's progress (0–1) in the last frame drawn by seek, or the live one. */
progress: () => progressNow(),
/** Seconds the hero has run (it doesn't advance off-screen or in a hidden tab). */
time: () => time,
state: () => (failed ? 'fallback' : !started ? 'loading' : reduced ? 'still' : recording ? 'recording' : raf ? 'running' : 'paused'),
async seek(seconds) {
if (failed) return Promise.reject(new Error('the effect failed; the still picture is showing'))
// an effect that shows footage seeks it first (effect.prepare), so the frame is exact
if (effect.prepare) {
const st = story ? (story.drive === 'scroll' ? script(seconds) : timed(seconds)) * story.length : seconds * speed
try {
await effect.prepare(st)
} catch (e) {
fail(e)
throw e
}
}
for (const a of root.getAnimations({ subtree: true })) {
a.pause()
a.currentTime = seconds * 1000
}
const p = cfg.motion.pointer ? path(seconds) : { x: 0, y: 0 }
smooth.x = p.x
smooth.y = p.y
if (pin) {
// scroll the page itself along the script, then read progress back from it
scrollTo(0, pin.scrollFor(script(seconds)))
sp = pin.read()
}
time = seconds
draw(seconds)
return new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(() => r(true))))
},
}
window.MotionHeroes = Object.assign(window.MotionHeroes || {}, { [id]: api })
window.MotionHero = api
start()
}
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |