Claude Skills by Intense-Visions

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

> 4-phase knowledge extraction, reconciliation, drift detection, and remediation with convergence loop. Keeps the business knowledge graph current and identifies coverage gaps.

> Single-page time-windowed product pulse. **Phase 3 ships the first-run interview only**: it converts vague intent into a concrete `pulse:` block in `harness.config.json`, refuses read-write DB credentials, and seeds from `STRATEGY.md` when present. The actual `harness pulse run` (Phases 2-4 of the runtime) is deferred to spec Phase 4.

> Rehearse an agent against a deliberately-broken fixture and score how well it recovers. Free-soloing a change in production is how a small planted defect becomes an incident. A fixture lets an agent practise the crux move — notice the defect, reach for the right gate, fix it without breaking anything else — on a rope first. The same fixtures double as a regression test for the harness's own gates: if `check-security` stops catching a leaked secret, the leaked-secret fixture's score drops.

> Fleet-wide branch and worktree pruning. Sync first, classify every ref against PR state and containment, prove nothing unpushed will be lost, then prune — and report the resulting ref state, not a delete count.

> Natural language entry point to all harness skills. Classifies intent by scope/domain, confirms routing with reasoning, dispatches to the appropriate skill.

> Repo-root strategic anchor. **Phase 2 of the strategic-anchor spec ships the skill**: a first-run interview that writes a valid `STRATEGY.md`, plus an update flow that re-interviews one section at a time with pushback against fluff, goals-as-strategy, and feature-lists-as-strategy. Downstream wiring (init, brainstorming, roadmap-pilot, ideate, knowledge graph) ships in spec Phases 3-7.

> Create families of related objects without specifying their concrete classes

> Convert the interface of a class into another interface that clients expect

> Decouple abstraction from implementation so both can vary independently

> Pass a request along a chain of handlers until one handles it

> Encapsulate operations as objects to support undo, queue, and logging

> Compose objects into tree structures and treat individual objects and composites uniformly

> Use constructor functions or ES6 classes to create and initialize objects

> Extend object behavior dynamically without modifying its source

> Load ES modules on demand with import() to reduce initial bundle size and enable code splitting

> Provide a simplified interface to a complex subsystem

> Create objects via a factory function without exposing instantiation logic to callers

> Share common state across many fine-grained objects to reduce memory usage

> Traverse a collection sequentially without exposing its internal structure

> Route component interactions through a central mediator to reduce direct coupling