Claude Skills by Intense-Visions

> Build SvelteKit routes using the file-system convention with +page.svelte, +layout.svelte, route groups, and dynamic segments

> Declare reactive state, derived values, and side effects in Svelte 5 using the runes API ($state, $derived, $effect, $props, $bindable)

> Intercept every request, populate locals, modify responses, and handle errors using SvelteKit's hooks.server.ts

> Choose the right state scope in SvelteKit: component-local runes, context API for subtree isolation, and module-level state for true singletons

> Share reactive state across any component tree using writable, readable, and derived stores with the Svelte store contract

> Test Svelte 5 components with Vitest and @testing-library/svelte — render, user events, store mocking, and async tick flushing

> Add enter/exit animations, list reordering motion, and spring physics to Svelte elements using built-in and custom transitions

> Directly read, write, and remove cache entries with QueryClient methods

> Chain queries that depend on each other's results using the enabled flag and useQueries

> Inspect cache state, query status, and network activity using the React Query DevTools panel

> Implement cursor-based pagination and "load more" UX with useInfiniteQuery

> Execute server-side mutations with useMutation, lifecycle callbacks, and retry configuration

> Update the UI immediately on mutation and roll back automatically if the server request fails

> Hydrate the client cache from server-fetched data using dehydrate/hydrate and HydrationBoundary

> Control cache freshness with invalidateQueries, staleTime, gcTime, and refetch strategies

> Structure query keys as type-safe factories to enable precise cache invalidation and scoped refetching

> Use useSuspenseQuery to integrate React's Suspense and error boundaries with TanStack Query

> Automate WCAG accessibility checks using axe-core with Playwright and jest-axe

> Test React components with Testing Library using user-centric queries and async utilities

> Test Svelte components with Testing Library using render, fireEvent, and waitFor

> Verify service compatibility using Pact consumer-provider contract tests

> Configure and interpret test coverage thresholds for meaningful quality signals

> LLM-judgment critique of test quality across vitest / jest / mocha / playwright / pytest. Fourth member of the craft-pipeline initiative. Per-`it`/`test` block critique with best-effort source pairing for contract-vs-implementation rubrics. Tests are often the worst-written code in a codebase precisely because the rule-based floor (coverage threshold) is so easy to clear. Emits 3-axis findings (tier × impact × confidence per ADR 0019).

> Choose the right test layer (unit/integration/E2E) and prevent flaky tests in CI

> Build maintainable test data using factory functions, builders, and faker.js

> Write integration tests that exercise real dependencies using test databases and containers

> Mock modules, functions, and timers in Vitest and Jest to isolate units under test

> Intercept HTTP requests in tests using Mock Service Worker handlers at the network level

> Measure and assert on code performance using vitest bench and timing budgets

> Write maintainable Playwright tests using page objects, fixtures, and parallel execution

> Configure Playwright test runner with fixtures, reporters, and browser contexts

> Generate exhaustive test cases automatically using fast-check property-based testing

> Use snapshot testing selectively for stable outputs, knowing when to avoid it

> Drive design through tests using red-green-refactor cycle and test-first discipline

> Write focused, isolated unit tests using AAA pattern with describe/it/expect

> Configure Vitest with workspaces, environments, coverage, and TypeScript integration

> Inject database clients, sessions, and request data into every procedure via `createTRPCContext`

> Throw typed TRPCErrors in procedures and format them consistently for client consumption

> Define type-safe inputs and outputs with Zod schemas for end-to-end type inference

> Add cross-cutting logic (auth checks, logging, rate limiting) to procedures via t.middleware

> Integrate tRPC with Next.js App Router using the fetch adapter, server-side callers, and React Server Components

> End-to-end type-safe data fetching with `api.xxx.useQuery`, `useMutation`, and cache invalidation via TanStack Query

> Organize type-safe RPC procedures into nested routers that merge into a single appRouter

> Stream real-time events to clients over WebSocket using tRPC subscriptions and observables

> Type async/await, Promise chains, and concurrent patterns correctly in TypeScript

> Prevent mixing semantically distinct primitives using branded opaque types

> Use abstract classes, private fields, access modifiers, and implements vs extends correctly

> Use conditional types, infer, and distributive logic to derive types programmatically

> Configure tsconfig with extends, project references, composite builds, and incremental compilation

> Extend existing types, modules, and namespaces via declaration merging and augmentation