Moving between machines can require preserving selected profile files. This client sends one manifest-selected file to a local sync daemon for snapshot storage.

Tracking shell profile loads requires a persistent startup marker. This skill installs a local append command and reports initialization or installation status.

Repeated shell setup can create duplicate startup entries. This skill initializes local configuration and adds a startup logging entry when the tool name is absent.

Moving selected profile files between machines requires a consistent snapshot workflow. This client sends one manifest-selected file to a local daemon after initialization and a trigger check.

Embedding web interfaces in Windows desktop apps requires careful initialization, messaging, and asset packaging. This skill guides WebView2 integration with local content mapping and explicit security boundaries.

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.