Claude Skills by Intense-Visions

> Test factories, fixtures, database seeding, and test data isolation. Establishes patterns for creating realistic, composable test data without coupling tests to specific database states.

> Audit microcopy, error messages, and UI strings for voice/tone consistency, clarity, and actionability. Produces a structured report with specific rewrites and a project voice guide when none exists.

> 3-level evidence-based verification. No completion claims without fresh evidence. "Should work" is not evidence.

> Binary pass/fail quick gate. Runs test, lint, typecheck — returns structured result. No judgment calls, no deep analysis. Pass or fail.

> Screenshot comparison, visual diff detection, and baseline management. Catches unintended CSS regressions, layout shifts, and rendering inconsistencies before they reach production.

> Audit `.github/workflows/*.yml` for quality and hygiene: stale path filters, missing gates, permission scoping, script injection, action pinning, self-trigger loops, and ratchet calibration. Every check taxonomy entry is grounded in defect patterns observed in downstream repos, where each defect silently broke a gate and was only caught by manual review.

> Strategy-grounded ideation fan-out at the head of the `-fleet` spine — compose `STRATEGY.md` tracks and supplied opportunity areas into a queue of disjoint themes, confirm the batch with the human in one up-front round, fan out worktree-isolated subagents that each run the **real** `harness-ideate` pipeline for one theme to its ranked artifact, collect every artifact back out of its worktree, independently re-derive every ranking instead of trusting a subagent's report, and hand back **one ...

> Scaffold or migrate a test-suite project — API, E2E/UI, or shared test library. Owns test-suite-specific archetype selection, shared-library vs in-repo scaffolding decision, layer variants, tag taxonomy, reporter stack, and custom report. Cross-cutting concerns (adoption level, personas, AGENTS.md base template, i18n, knowledge graph, roadmap nudge, final commit) delegate to `harness-initialize-project`.

> Autonomous open-issue-backlog **intake** orchestrator — enumerate the open-issue queue, triage each issue (label, dedup, route, prioritize), confirm the destructive closes with the human in one up-front round, fan out concurrency-governed triage subagents over queue slices, independently re-derive every mutation from the issue's own signals, and hand the downstream fleets a clean, ranked, deduped, routed queue. The fleet never silently closes an issue and never trusts a subagent's self-repo...

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