Skills Directory
Claude Skills by Intense-Visions
github.com/Intense-Visions> 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).
> Detect documentation that has drifted from code. Find stale docs before they mislead developers and AI agents.
> 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).
> Autonomous documentation-drift remediation sweep — enumerate the doc-drift/undocumented backlog by composing the existing documentation-floor detectors (`detect-doc-drift`, `harness check-docs`), fold the codebase into independent doc-fix areas, rank them by staleness value, confirm the batch with the human in one up-front round, fan out worktree-isolated subagents that each run the **real** per-area documentation pipeline (`harness-docs-pipeline --fix` to convergence), independently verify...
> 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
> Validate architectural layer boundaries and detect dependency violations. No code may violate layer constraints — this is a hard gate, not a suggestion.
> 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.
> Conductor for the `-fleet` family — one tier above the members, coordinating the fleets themselves rather than fanning out over an item-queue. It derives the run as a hybrid DAG whose wave boundaries come from a dependency edge **or** an evidence-fidelity exclusivity requirement — either one alone sufficient — instead of accepting a hand-picked order, enforces **one global** leaf-slot budget across every fleet in flight rather than the sum of their per-fleet governors, deconflicts the lanes...
> 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.
> Eliminate null checks by providing default no-op implementations of interfaces.
> Implement push-based notification between Subject and Observer with typed subscriptions.
> Clone objects using prototype registry and structured clone for deep copy scenarios.
> Control access to an object using virtual, protection, logging, and caching proxy patterns.
> Ensure a class has exactly one instance using module-level singletons and WeakRef patterns.
> Replace conditional logic with state objects that delegate behavior to the current state.
> Encapsulate interchangeable algorithms behind a common interface for runtime selection.
> Define an algorithm skeleton in a base class with abstract steps filled by subclasses.