Claude Skills by Intense-Visions

> 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

> Add reusable behaviors to classes without deep inheritance chains

> Encapsulate private state and expose a public API using closures or ES modules

> Notify subscribers automatically when an observable object's state changes

> Share properties and methods across instances via the prototype chain

> Make shared data available to multiple consumers without prop-drilling

> Intercept and control object property access with ES6 Proxy

> Define all logic privately and selectively reveal only the public API

> Ensure a class has only one instance and provide a global access point

> Allow an object to alter its behavior when its internal state changes

> Use static import declarations to load ES modules at parse time for tree-shaking and static analysis

> Define a family of algorithms and make them interchangeable without altering the client

> Define the skeleton of an algorithm in a base class and let subclasses override specific steps

> Add new operations to object structures without modifying the objects

> LLM-judgment critique of knowledge-entry quality. Critiques `docs/knowledge/` entries (EXCLUDING `decisions/` — that's spec-craft's territory) against a curated rubric catalog: does this state a load-bearing FACT or paraphrase the code? Would deleting it lose specific signal? Does it earn its place in the knowledge graph as `business_fact` / `business_rule` / `business_concept` / `business_decision`? Fifth non-design member of the craft-pipeline initiative. Emits 3-axis findings (tier × imp...

> Route, aggregate, and secure client requests through an API gateway or BFF pattern.

> Isolate failures with bulkheads using thread pools and semaphores to protect shared resources.

> Prevent cascading failures with circuit breaker, half-open state, and fallback logic.

> Centralize configuration, feature flags, and secrets management across services.

> Separate read and write models to optimize query and command performance independently.

> Design service boundaries using bounded contexts, DDD, and functional cohesion principles.

> Propagate trace context and emit spans across services using OpenTelemetry.

> Store state as an immutable sequence of events with projections, snapshots, and replay.

> Implement /health and /ready endpoints for liveness and readiness probes in containers.

> Guarantee at-least-once event delivery using a transactional outbox and polling publisher.

> Coordinate distributed transactions using choreography and orchestration sagas with compensation.

> Implement service registration and dynamic discovery with health checks in microservices.

> Inject cross-cutting concerns like observability and security via a sidecar proxy.

> Migrate monoliths incrementally using the strangler fig pattern with facade routing.

> Create fluid 60fps animations with React Native Reanimated using shared values, worklets, and layout animations

> Deploy React Native apps with EAS Build, EAS Submit, OTA updates, and automated CI/CD pipelines