Claude Skills by Intense-Visions

> Scroll-driven depth — rate-differential parallax, scroll-triggered reveals, sticky sections, scroll narrative, performance constraints, motion sensitivity

> Optimizing for reading — line length (measure), line height (leading), paragraph spacing, text alignment, hyphenation, and reading patterns (F-pattern, Z-pattern)

> Responsive as a design decision — content-first breakpoints, progressive disclosure, and treating every viewport as a first-class design target

> Type across viewports — fluid typography with CSS clamp(), viewport-relative scaling, minimum readable sizes, and maintaining hierarchy across breakpoints

> UI state inventory — empty, loading, partial, error, success, offline, disabled, read-only, and how each state communicates system status

> Token taxonomy covering primitive, semantic, and component tokens with naming conventions, aliasing chains, theme switching, and the token-to-code pipeline.

> Temporal design — enter/exit asymmetry, stagger patterns, easing functions (ease-out for enter, ease-in for exit), duration by element size, interruptibility

> Mathematical type scales — modular, major third, perfect fourth, golden ratio, custom scales, and when each is appropriate

> Establishing reading order through type — size, weight, color, spacing, case, and position as hierarchy signals

> Anatomy of type — x-height, ascenders, descenders, counters, serifs, stroke contrast, optical sizing, and how anatomy affects readability

> Directing attention through size, color, contrast, position, isolation, and motion — the system that tells the eye where to go first, second, and third

> Font loading strategy — performance vs. FOUT/FOIT, variable fonts, subsetting, system font stacks, and font-display options

> Space as a design element — macro vs. micro whitespace, breathing room, density control, and whitespace as a signal of quality and luxury

> Detect design-system drift — hardcoded values where tokens exist, and raw HTML primitives where registered components exist. The rule-based floor of design-pipeline (detect half). Reports findings; never modifies source. Pairs with a separate align-design-system fixer skill (deferred to a sibling sub-project).

> LLM-judgment critique of documentation quality — the ceiling counterpart to the rule-based documentation floor (harness-detect-doc-drift / harness-check-docs / harness-docs-pipeline, which enforce existence, link freshness, and coverage). The direct structural twin of harness-design-craft: the floor keeps docs from being broken; docs-craft asks whether they are any good. Emits 3-axis findings (tier × impact × confidence per ADR 0019).

> Filter Drizzle queries with eq(), and(), or(), between(), sql template tag, and custom conditions

> Manage Drizzle schema evolution with drizzle-kit generate/push/migrate and introspect

> Optimize Drizzle queries with prepared statements, db.batch(), explain analysis, and join-based N+1 avoidance

> Compose type-safe SQL with Drizzle's fluent query builder for select, insert, update, and delete

> Execute raw SQL safely in Drizzle with the sql template tag, db.execute(), and placeholder()

> Define Drizzle relations with relations(), one(), many(), references(), and inferred types

> Define Drizzle ORM schemas with pgTable/mysqlTable/sqliteTable, column types, indexes, and constraints

> Execute atomic Drizzle operations with db.transaction(), nested transactions, and rollback semantics

> Integrate Drizzle with Next.js using Neon/Vercel Postgres, edge runtime, and connection pooling

> Define and evolve event schemas using a schema registry with Avro, Protobuf, or JSON Schema.

> Run event storming workshops to discover domain events, commands, and bounded contexts.

> Handle duplicate message delivery safely using idempotency keys and deduplication stores.

> Produce and consume Kafka messages with partitioning, consumer groups, and offset management.

> Use message queues for reliable async delivery with competing consumers and dead letter queues.

> Reliably publish domain events using the transactional outbox and CDC polling approach.

> Implement publisher-subscriber communication with topic-based routing and fan-out delivery.

> Use Redis pub/sub channels and keyspace notifications for lightweight real-time messaging.

> Coordinate distributed workflows through event chains and compensation events without an orchestrator.

> Stream one-way server events to browsers using Server-Sent Events and EventSource.

> Implement reliable webhook delivery with retry backoff, signature verification, and queuing.

> Implement bidirectional real-time communication using WebSocket protocol and Socket.io.

> Create families of related objects through factory interfaces without coupling to concrete types.

> Wrap incompatible interfaces to make them work together without modifying source code.

> Separate abstraction from implementation to allow them to vary independently.

> Construct complex objects step-by-step using fluent builders and director classes.

> Pass requests along a handler chain with short-circuit and async chain support.

> Encapsulate operations as command objects to support undo, redo, and command queuing.

> Compose objects into tree structures and treat individual and composite objects uniformly.

> Attach additional behavior to objects at runtime by wrapping them in decorator objects.

> Provide a simplified interface to a complex subsystem to reduce coupling for clients.

> Define a factory interface that subclasses use to decide which object to instantiate.

> Share fine-grained objects to reduce memory usage by separating intrinsic and extrinsic state.

> Traverse collections with Symbol.iterator and generators for lazy, composable sequences.

> Decouple components by routing communication through a central mediator or event bus.

> Capture and restore object state using mementos for undo history and time-travel.