Claude Skills by Intense-Visions

> LLM-judgment critique of code quality / readability for TS/JS source — the ceiling counterpart to the rule-based code floor (`harness-cleanup-dead-code` for dead code / drift, `harness-enforce-architecture` for layer boundaries + import direction, and complexity thresholds). The floor keeps code from being broken or forbidden; code-craft asks whether it is any good — does it reveal intent, is the control flow honest, does each abstraction earn its keep, would a senior nod or wince. Per-unit...

> LLM-judgment critique of prose-in-code across six surfaces: error messages, log lines, CLI output strings, commit subjects, PR descriptions, and code comments. Primary domain is error messages (universally bad in most codebases). Third member of the craft-pipeline initiative. NO rule-based floor exists — pure ceiling. Emits 3-axis findings (tier × impact × confidence per ADR 0019).

> Create performant CSS animations with Tailwind transitions, keyframe utilities, and motion-safe considerations

> Build type-safe component variants with class-variance-authority for consistent, composable styling APIs

> Scope CSS to components with CSS Modules for collision-free class names and co-located styles

> Build reusable styled components with Tailwind, CVA variants, and polymorphic prop patterns

> Implement dark mode with Tailwind's dark variant, CSS custom properties, and user preference detection

> Define and manage design tokens for colors, spacing, typography, and effects in Tailwind CSS

> Style accessible headless components from Radix UI and Headless UI with Tailwind data-attribute selectors

> Build common layouts with Tailwind flexbox and grid utilities for dashboard, marketing, and app shells

> Optimize CSS performance with content-visibility, containment, efficient selectors, and Core Web Vitals-friendly patterns

> Build responsive layouts with Tailwind's mobile-first breakpoints, container queries, and fluid typography

> Resolve Tailwind class conflicts intelligently with tailwind-merge for safe className composition and overrides

> Apply Tailwind CSS utility-first patterns for consistent, maintainable component styling

> The mechanisms that make ACID guarantees real: Write-Ahead Logging ensures atomicity and durability, fsync ensures persistence to physical media, and crash recovery replays the WAL to restore a consistent state.

> ACID guarantees that database transactions are processed reliably: each transaction is all-or-nothing (Atomic), leaves the database in a valid state (Consistent), operates as if no other transactions are running (Isolated), and once committed, persists even through crashes (Durable).

> The simplest hierarchical model where each row stores a reference to its parent, traversed with recursive CTEs for subtree and ancestor queries.

> Recording who changed what, when, and why, using trigger-based or application-level change tracking with immutable append-only logs.

> The default index type in PostgreSQL and MySQL, B-tree indexes support equality and range queries on ordered data with O(log n) lookup performance.

> In a distributed system, when a network partition occurs, you must choose between consistency (every read returns the most recent write) and availability (every non-failing node returns a response) -- you cannot have both simultaneously.

> Storing all ancestor-descendant pairs in a separate table for O(1) subtree and ancestor lookups with manageable write costs.

> Multi-column indexes that accelerate queries filtering on column combinations, governed by the leftmost prefix rule and the ESR (Equality, Sort, Range) column ordering strategy.

> External connection poolers like PgBouncer sit between the application and database, multiplexing many application connections onto fewer database connections to prevent connection exhaustion.

> Tuning max_connections, understanding per-connection memory overhead, and right-sizing database connections for on-premise and serverless environments.

> Indexes that contain all columns needed by a query, enabling index-only scans that skip heap table access entirely.

> Deadlocks occur when two or more transactions hold locks and each waits for a lock the other holds; prevention through consistent lock ordering and detection through timeout-based abort resolves them.

> Intentionally introducing controlled redundancy into a normalized schema to eliminate expensive joins or aggregations, applied only after measured proof of a performance problem.

> Using JSONB columns to store semi-structured data alongside relational tables, with indexing strategies and guidelines for when to embed vs normalize.

> A schema pattern for storing dynamic, user-defined attributes as rows instead of columns -- usually avoided in favor of JSONB or polymorphic alternatives, but occasionally justified for genuinely unbounded attribute sets.

> If no new updates are made, all replicas will eventually converge to the same value -- a consistency model that trades immediate agreement for higher availability and lower latency.

> Add new structure, migrate data, remove old structure -- the three-phase pattern for safe column renames, type changes, and table restructuring.

> How to read query execution plans to identify performance bottlenecks, row count misestimations, and missing indexes.

> Indexes on computed expressions and specialized index types (GIN, GiST) for non-scalar data like JSONB, arrays, and full-text search.

> Every column holds a single atomic value, no repeating groups exist, and every row is uniquely identifiable by a primary key.

> Modeling vertices and edges in SQL tables for social graphs, dependency networks, and recommendation systems with recursive queries -- and knowing when SQL stops being practical.

> Optimized for equality-only lookups with O(1) average access time, hash indexes are smaller than B-tree when range queries and ordering are never needed.

> Choosing between adjacency list, nested sets, closure table, and materialized path based on read/write ratio, query patterns, and tree depth.

> Distributing rows of a table across multiple database instances (shards) to scale beyond the capacity of a single server, with careful attention to shard key selection and cross-shard query complexity.

> The four SQL standard isolation levels control which concurrent transaction side-effects are visible, with PostgreSQL implementing them via MVCC snapshots rather than traditional locking.

> Selecting the right isolation level requires matching the workload's correctness requirements against the performance cost and retry complexity of stricter levels.

> Forward-only vs reversible migrations, data backfill safety, and blue-green schema patterns for confident schema evolution.

> MVCC allows readers and writers to operate concurrently without blocking each other by maintaining multiple versions of each row, with visibility determined by transaction snapshots.

> Encoding hierarchy position with left/right boundary numbers for O(1) subtree and ancestor queries at the cost of expensive writes.

> Optimistic locking assumes conflicts are rare, allows concurrent reads without locks, and detects conflicts at write time using version columns or conditional updates.

> Indexes with a WHERE clause that index only a subset of rows, reducing size and improving performance for targeted query patterns.

> Pessimistic locking acquires locks before modifying data, guaranteeing exclusive access and preventing conflicts at the cost of reduced concurrency.

> Modeling inheritance hierarchies and type-varying relationships in relational databases using single-table inheritance (STI), class-table inheritance (CTI), or shared foreign key patterns.

> Structural query transformations that help the planner choose better execution plans without changing results.

> How the planner uses table statistics (pg_stats, histograms, most-common-values) to estimate row counts and choose execution plans.

> The SQL standard defines three read anomalies (dirty, non-repeatable, phantom) that isolation levels progressively prevent, plus PostgreSQL adds write skew as a fourth anomaly relevant to Serializable.