Slow loading and delayed interactions require different fixes, and laboratory scores can hide real user problems. This skill guides measurement and targeted browser performance improvements.

Browser GPU workloads can fail across devices or lose performance through inefficient resource handling. This skill guides WebGPU implementation with capability checks, usable fallbacks, validation, and targeted measurement.

Raw WebGL rendering can slow down through excessive draw calls, state changes, and texture bandwidth. This skill guides context setup, resource handling, and targeted optimization.

Inconsistent interfaces can hide actions, weaken accessibility, and fail on smaller screens. This skill provides focused design decisions and evidence-based review guidance.

Compute-heavy browser workloads can suffer from JavaScript processing costs and frequent data transfers. This skill guides Rust WebAssembly integration and optimization based on measured bottlenecks.

GPU visuals can fail when shader APIs, package versions, and application lifecycles do not align. This skill guides version-aware vgpu development, integration, performance measurement, and validation.

Duplicated server state and inconsistent query keys can cause stale data and unnecessary requests. This skill guides TanStack patterns for caching, mutations, routing, and rendering.

Service workers can leave users with stale pages, broken updates, or unsafe offline caches. This skill guides lifecycle handling, cache ownership, offline fallbacks, and browser-aware PWA behavior.

React Three Fiber scenes can waste CPU and GPU resources through inefficient animation, loading, and rendering. This skill guides implementation choices for frame loops, instancing, assets, and adaptive quality.

Choosing a browser renderer without measurements can reduce accessibility and increase complexity. This skill guides renderer selection, performance diagnosis, and fallback planning.

Async errors, shared mutations, and weak validation can make JavaScript behavior unreliable. This skill guides focused fixes using modern language features and defensive runtime practices.

Inconsistent markup causes accessibility, usability, and search problems. This skill guides you toward semantic structure, resilient forms, and useful document metadata.

Database changes can damage data when scope, recovery, and permissions are unclear. This skill guides minimal schema designs and reviewed migration plans before authorized database access.

CSS layout bugs and conflicting rules make responsive interfaces difficult to maintain. This skill guides stylesheet changes using modern layout, cascade, theming, and performance techniques.

Conflicting cache policies can delay updates and expose personalized content through shared caches. This skill guides HTTP freshness, revalidation, and invalidation decisions across cache layers.

Chrome web problems often require evidence from several browser surfaces, which makes diagnosis slow and inconsistent. This skill provides a focused workflow for reproducing issues, collecting bounded evidence, and verifying fixes with agent-browser and Chrome DevTools.

Unclear requirements can lead AI assistants to make consequential choices without user agreement. This skill guides focused questions, bounded inspection, and review before material changes.

Radix-to-Base migrations can break wrapper behavior, styles, and consumer props. This skill applies component mappings, progressive workflows, verification, and migration reports.

Delivery data is difficult to interpret when statuses, channels, and webhook evidence disagree. This skill builds reliable cohorts and identifies the strongest supported cause.

Maintaining issues and project updates across separate interfaces takes time. This skill gives your assistant documented Linear CLI workflows for finding work and applying requested changes.