Agent development can fail when guidance does not match the installed eve version. This skill directs your assistant to bundled documentation before project changes.

NestJS changes can introduce incompatible syntax, hidden side effects, and public API regressions. This skill guides repository inspection, focused implementation, and evidence-based verification.

Unclear responsibilities and unnecessary abstractions make NestJS code difficult to change and test. This skill guides evidence-based object design, pattern selection, and behavior-preserving refactoring.

Mixed changes and unclear publication requests can produce misleading commits or unintended remote updates. This skill guides verified Git changes and accurate messages within authorized scope.

NestJS runtime changes can create latency, security, and deployment failures when teams lack clear contracts and measurements. This skill guides component selection, bottleneck diagnosis, and reliable implementation using repository evidence and focused tests.

Source code alone cannot establish whether a NestJS feature satisfies its roadmap. This skill compares requirements with revision-specific evidence and reports completed work, gaps, legacy paths, bugs, and blockers.

NestJS repositories can hide boundary flaws and runtime risks that lint results alone cannot reveal. This skill combines local evidence collection and semantic review into one prioritized report.

Unclear module boundaries make NestJS changes harder to test and coordinate. This skill guides evidence-based architecture decisions, explicit ownership, and incremental boundary repairs.

Large source trees make symbol navigation and caller discovery expensive. This skill guides structural indexing with reusable caches and coverage-aware queries while preserving lexical discovery.

Many application features need semantic judgments, but free-form model responses are difficult to combine reliably in code. TypeSafe helps developers design small typed judgments and compose them into routing, ranking, extraction, verification, and interactive workflows.

iOS testing often requires switching between agent tools, simulator controls, and evidence collection. This skill routes simulator interaction through Orca and loads guidance matched to the active CLI.

Development teams can lose requirement evidence across planning, implementation, review, and release. This skill adds RVTF traceability while preserving Superpowers task boundaries and control.

Teams can lose requirements when agent-skill work moves from planning to implementation and review. This skill keeps requirements, acceptance evidence, review state, and completion claims connected through a clear traceability process.

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.

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.