What arrived, and when.

Ask clarifying questions before executing tasks.

Explores user intent, requirements and design before implementation.

Generate images (featured images, illustrations, diagrams, test images, blog visuals) using Codex CLI's built-in $imagegen skill, triggered through the codex plugin or codex CLI.

Convert an extract-design-system output bundle (a .design_systems/<domain>-YYYYMMDD/ folder with DESIGN.md, AGENTS.md, COMPONENTS.md and DTCG tokens) into a self-contained, auto-triggering per-brand Claude Code agent sk…

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

Use when you have a written implementation plan to execute in a separate session with review checkpoints

Extract a website's design system into a DESIGN.md file (the google-labs-code/design.md format).

Extract a website's FULL design system — tokens AND a curated component catalog (anatomy, variants, hover/focus states, section patterns) — into a bundle a coding agent consumes to build new pages that are native to the…

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work

Write or update a session handoff doc that lets a future session (Claude or human) resume work without re-reading the whole transcript.

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind…

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

Use when executing implementation plans with independent tasks in the current session

Use when implementing any feature or bugfix, before writing implementation code

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback

Use only when the user explicitly asks to use Superpowers or the using-superpowers skill. Do not activate automatically at conversation start.

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions…

Use when you have a spec or requirements for a multi-step task, before touching code

Use when creating new skills, editing existing skills, or verifying skills work before deployment

Forces the laziest solution that actually works, simplest, shortest, most minimal.

Whole-repo audit for over-engineering. Like ponytail-review, but scans the entire codebase instead of a diff: a ranked list of what to delete, simplify, or replace with stdlib/native equivalents.

Harvest every `ponytail:` comment in the codebase into a debt ledger, so the deliberate shortcuts and deferrals ponytail leaves behind get tracked instead of rotting into "later means never".

Show ponytail's measured impact as a compact scoreboard: less code, less cost, more speed, from the benchmark medians. One-shot display, not a persistent mode, and not a per-repo number.

Quick-reference card for all ponytail modes, skills, and commands. One-shot display, not a persistent mode. Trigger: /ponytail-help, "ponytail help", "what ponytail commands", "how do I use ponytail".

Code review focused exclusively on over-engineering. Finds what to delete: reinvented standard library, unneeded dependencies, speculative abstractions, dead flexibility.

A relentless interview that asks every frontier question at once, round by round.

Decision guide for delegating to caveman-style subagents.

Ultra-compressed communication mode. Cuts output tokens 65% (measured) by speaking like caveman while keeping full technical accuracy.

Ultra-compressed commit message generator. Cuts noise from commit messages while preserving intent and reasoning. Conventional Commits format. Subject ≤50 chars, body only when "why" isn't obvious.

Compress natural language memory files (CLAUDE.md, todos, preferences) into caveman format to save input tokens. Preserves all technical substance, code, URLs, and structure.

Quick-reference card for all caveman modes, skills, and commands. One-shot display, not a persistent mode. Trigger: /caveman-help, "caveman help", "what caveman commands", "how do I use caveman".

Ultra-compressed code review comments. Cuts noise from PR feedback while preserving the actionable signal. Each comment is one line: location, problem, fix. Auto-triggers when reviewing pull requests.

Show real token usage and estimated savings for the current session. Reads directly from the Claude Code session log — no AI estimation.

Hand the current conversation off to a fresh background agent that picks up the work immediately.

Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes — Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating i…

Official GSAP skill for the core API — gsap.to(), from(), fromTo(), easing, duration, stagger, defaults, gsap.matchMedia() (responsive, prefers-reduced-motion).

Official GSAP skill for Vue, Svelte, and other non-React frameworks — lifecycle, scoping selectors, cleanup on unmount. Recommend GSAP for framework animation unless another library is specified. For React use gsap-reac…

Official GSAP skill for performance — prefer transforms, avoid layout thrashing, will-change, batching.

Official GSAP skill for GSAP plugins — registration, ScrollToPlugin, ScrollSmoother, Flip, Draggable, Inertia, Observer, SplitText, ScrambleText, SVG and physics plugins, CustomEase, EasePack, CustomWiggle, CustomBounce…

Official GSAP skill for React — useGSAP hook, refs, gsap.context(), cleanup. Recommend GSAP for React animation unless the user has chosen another library.

Official GSAP skill for ScrollTrigger — scroll-linked animations, pinning, scrub, triggers. Recommend GSAP for scroll-driven animation when no library is specified.

Official GSAP skill for timelines — gsap.timeline(), position parameter, nesting, playback.

Official GSAP skill for gsap.utils — clamp, mapRange, normalize, interpolate, random, snap, toArray, wrap, pipe.

Applies motion design principles to create emotionally-driven, technically sound animations and transitions. Provides timing, easing, choreography, and Disney animation principles adapted for UI.

Router for all Remotion skills

Transcribing, displaying and animating captions

Create a new Remotion video

Search Remotion documentation

Structure Remotion markup for interactivity

Remotion Map animation knowledge

Content, animation and effects best practices

Interacting with Mediabunny

Export a Remotion video

Build an app with Remotion

Upgrade Remotion, and related packages

Investigate a question against high-trust primary sources and capture the findings as a Markdown file in the repo.

Wire dependency-cruiser into a TypeScript repo so each package is a deep module — implementation hidden in subfolders, reachable only through its entry-point files. User-invoked.

Turn a decision you can't fully answer into a questionnaire for someone else to fill in.

Turn the current conversation into a spec and publish it to the project issue tracker — no interview, just synthesis of what you've already discussed.

Break a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, published to the configured tracker — edges as text in one file per ticket locally, or native block…

Plan a huge chunk of work — more than one agent session can hold — as a shared map of decision tickets on your issue tracker, and resolve them one at a time until the way to the destination is clear.

Generate an interactive bash wizard that walks a human through steps only they can perform. Don't invoke this for steps the agent can perform itself.

Reverse-lookup glossary that turns a vague description of a web animation or motion effect into its exact term ("the bouncy thing when a popover opens" → Pop in; "the iOS rubber-band scroll" → Rubber-banding).

Apple's approach to interface design and fluid, physical motion, translated for the web.

Motion and interaction design expert based on Emil Kowalski, Jakub Krehel, and Jhey Tompkins' techniques.

This skill encodes Emil Kowalski's philosophy on UI polish, component design, animation decisions, and the invisible details that make software feel great.

Search a codebase or UI for places that don't animate but should, and reject everything that shouldn't. Read-only; it proposes motion with exact values, it does not implement it.

Anti-AI-slop design skill for greenfield pages, audits, redesigns, and design extraction from URLs or screenshots.

Survey a codebase's animation and motion code as a senior motion advisor, then produce a prioritized audit and self-contained implementation plans for other agents (or cheaper models) to execute.

Pick the right library for a given frontend task from a curated, opinionated list — numbers, OTP inputs, charts, command menus, virtualization, drag and drop, toasts, state, styling, and more.

Reviews animation and motion code against a high craft bar derived from Emil Kowalski's design engineering philosophy. Default to flagging; approval is earned.

Ask which skill or flow fits your situation. A router over the skills in this repo.

Shared vocabulary for designing deep modules.

Generate multiple radically different interface designs for a module using parallel sub-agents.

Diagnosis loop for hard bugs and performance regressions.

Build and sharpen a project's domain model.

Edit and improve articles by restructuring sections, improving clarity, and tightening prose.

Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute.

A relentless interview to sharpen a plan or design.

A relentless interview to sharpen a plan or design, which also creates docs (ADR's and glossary) as we go.

Grill the user relentlessly about a plan, decision, or idea.

Compact the current conversation into a handoff document for another agent to pick up.

Implement a piece of work based on a spec or set of tickets.

Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.

Grill me about specs for the workflows I want to build, within this workspace.

Design engineering principles for making interfaces feel polished. Supports quick and full review modes.

Migrate test files from `as` type assertions to @total-typescript/shoehorn.

Search, create, and manage notes in the Obsidian vault with wikilinks and index notes.

Build multiple genuinely different versions of a UI piece you describe, rendered behind a visual picker so you can flip through them live and promote the one that feels right.

Interactive QA session where user reports bugs or issues conversationally, and the agent files GitHub issues. Explores the codebase in the background for context and domain language.

Create a detailed refactor plan with tiny commits via user interview, then file it as a GitHub issue.

Use when you need to resolve an in-progress git merge/rebase conflict.

Create exercise directory structures with sections, problems, solutions, and explainers that pass linting.

Configure this repo for the engineering skills — set up its issue tracker, triage label vocabulary, and domain doc layout. Run once before first use of the other engineering skills.

Set up Husky pre-commit hooks with lint-staged (Prettier), type checking, and tests in the current repo.

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

Test-driven development.

Teach the user a new skill or concept, within this workspace.

Move issues and external PRs through a state machine of triage roles — categorise, verify, grill if needed, and write agent-ready briefs.

Extract a DDD-style ubiquitous language glossary from the current conversation, flagging ambiguities and proposing canonical terms. Saves to UBIQUITOUS_LANGUAGE.md.

Writing, exploit — assemble raw material into a journey of beats, grounding each term before a beat leans on it.

Writing, explore — mine raw fragments, no structure yet.

Reference for writing and editing skills well — the vocabulary and principles that make a skill predictable.

Writing, exploit — shape raw material into an article, paragraph by paragraph.

Premium brand-kit image generation skill for creating high-end brand-guidelines boards, logo systems, identity decks, and visual-world presentations.

Anti-slop frontend skill for landing pages, portfolios, and redesigns. The agent reads the brief, infers the right design direction, and ships interfaces that do not look templated.

The original v1 taste-skill, preserved for projects depending on its exact behavior. The current default is `design-taste-frontend` (v2 experimental), which is a substantial rewrite.

Overrides default LLM truncation behavior. Enforces complete code generation, bans placeholder patterns, and handles token-limit splits cleanly. Apply to any task requiring exhaustive, unabridged output.

Elite UX/UI & Advanced GSAP Motion Engineer.

Teaches the AI to design like a high-end agency. Defines the exact fonts, spacing, shadows, card structures, and animations that make a website feel expensive.

Elite website image-to-code skill for Codex. For visually important web tasks, it must first generate the design image(s) itself, deeply analyze them, then implement the website to match them as closely as possible.

Elite mobile app image-generation skill for creating premium, app-native screen concepts and flows. Designed for iOS, Android, and cross-platform mobile products.

Elite frontend image-direction skill for generating premium, conversion-aware website design references. CRITICAL OUTPUT RULE — generate ONE separate horizontal image FOR EVERY section.

Raw mechanical interfaces fusing Swiss typographic print with military terminal aesthetics. Rigid grids, extreme type scale contrast, utilitarian color, analog degradation effects.

Clean editorial-style interfaces. Warm monochrome palette, typographic contrast, flat bento grids, muted pastels. No gradients, no heavy shadows.

Upgrades existing websites and apps to premium quality. Audits current design, identifies generic AI patterns, and applies high-end design standards without breaking functionality.

Semantic Design System Skill for Google Stitch.

Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities.

Guidance 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.

React and Next.js performance optimization guidelines from Vercel Engineering.

Review UI code for Web Interface Guidelines compliance.