Claude Skills by Intense-Visions

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

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

> Add operations to object structures without modifying them using double dispatch.

> Configure and run Apollo Server with plugins, context, data sources, and framework integrations

> Implement authentication and authorization in GraphQL with context-based identity, directives, and field-level guards

> Structure GraphQL client code with fragments, cache normalization, and optimistic updates for responsive UIs

> Generate type-safe TypeScript code from GraphQL schemas and operations to eliminate manual type maintenance

> Batch and cache data fetches to eliminate N+1 queries in GraphQL resolvers

> Handle errors in GraphQL APIs with structured error types, result unions, and server-side error formatting

> Compose a unified GraphQL API from independently deployed subgraph services using Apollo Federation

> Implement cursor-based and offset pagination in GraphQL using the Relay connection specification

> Optimize GraphQL API performance with query complexity analysis, caching, persisted queries, and DataLoader

> Implement resolvers with clean separation between data fetching, business logic, and response shaping

> Design expressive, evolvable GraphQL schemas with clear type hierarchies and strong nullability contracts

> Implement real-time data streaming with GraphQL subscriptions over WebSocket connections

> Mechanically audit whether a project's harness is load-bearing. Orchestrates the deterministic check-harness-strength engine; interprets results. Not a deep/AI review.

> Cross-dimensional codebase audit orchestrator — classify the repo's shape, fan out parallel read-only audit agents that compose existing harness skills, adversarially confirm high-severity findings, dedup against the existing issue tracker, and publish grouped thematic tracking issues with checkbox action lists. Optionally hand off to worktree-isolated fix agents, one per theme, gated on human confirmation. Motivated by repeated manual audits of downstream overlay repos: a full sweep surfac...

> Monthly retrospective over skill-adoption telemetry. Reads `.harness/metrics/adoption.jsonl`, ranks the most-invoked, most-failing, and abandoned-mid-workflow skills, flags ever-invoked skills that have gone quiet, and reports how much of the catalog emits any telemetry at all. Produces a dated Markdown report and surfaces the highlights that warrant follow-up. Compounding-via-learning at the catalog grain.

> 5-phase post-mortem capture. When a problem is solved, distill it into a structured doc at `docs/solutions/<track>/<category>/<slug>.md` so the next person (or agent) finds the playbook before re-deriving it.

> LLM-judgment-based design ceiling-raiser. Three branchable phases — CRITIQUE finds what's mediocre, POLISH applies high-craft moves, BENCHMARK scores against curated exemplars. The ceiling counterpart to harness-design (declared-intent enforcement, rule-based) and the design-pipeline floor audits.

> Orchestrator composing all 6 design-pipeline sub-projects into a single sequential pipeline with convergence-based remediation: FRESHEN → DETECT → FIX → AUDIT → FILL → REPORT. Produces a unified `pass` / `warn` / `fail` verdict and a per-phase report. Mirrors harness-docs-pipeline in shape; consumes the formal verifier interface generically so a 5th rule-based verifier composes for free.

> `harness graph status` answers "how big is the graph?". It cannot answer "is any of this true?". This skill answers the second question, and reports what it examined so a quiet result can never be mistaken for a clean one.

> Pre-brainstorm ideation. Generates candidate ideas, critiques each against its strongest objection, and ranks them by `(impact × confidence) ÷ effort`. Writes a single ranked artifact to `docs/ideation/<slug>-YYYY-MM-DD.md`. **Produces ranked ideation, not specs** — brainstorming consumes the output.

> Verify system wiring, materialize knowledge artifacts, and update project metadata. Integration is a gate, not a discovery phase -- it confirms that planned integration tasks completed.