Claude Skills by janpereira-dev

Adopt Angular deferrable views in bounded post-upgrade modernization slices after Angular 19 is stable. Use when improving render timing, route splitting, and loading behavior with @defer without mixing the change into a version hop.

Adopt Angular deferrable views in bounded post-upgrade modernization slices after Angular 20 is stable. Use when improving render timing, route splitting, and loading behavior with @defer without mixing the change into a version hop.

Adopt Angular deferrable views in bounded post-upgrade modernization slices after Angular 21 is stable. Use when improving render timing, route splitting, and loading behavior with @defer without mixing the change into a version hop.

Adopt standalone components and bootstrap APIs in bounded post-upgrade modernization slices after Angular 19 is stable. Use when reducing NgModule usage incrementally or converting bounded feature areas without mixing the change into a version hop.

Adopt standalone components and bootstrap APIs in bounded post-upgrade modernization slices after Angular 20 is stable. Use when reducing NgModule usage incrementally or converting bounded feature areas without mixing the change into a version hop.

Adopt standalone components and bootstrap APIs in bounded post-upgrade modernization slices after Angular 21 is stable. Use when reducing NgModule usage incrementally or converting bounded feature areas without mixing the change into a version hop.

Adopt standalone components and bootstrap APIs in bounded post-upgrade modernization slices after Angular 18 is stable. Use when reducing NgModule usage incrementally or converting bounded feature areas without mixing the change into a version hop.

Use this skill to modernize an app already on Angular 22 without mixing in the upgrade hop.

Prepare an Angular app for zoneless execution in bounded post-upgrade modernization slices after Angular 17 is stable. Use when reducing reliance on Zone.js timing, event patching assumptions, and implicit change detection behavior without mixing the work into a version hop.

Prepare an Angular app for zoneless execution in bounded post-upgrade modernization slices after Angular 18 is stable. Use when reducing reliance on Zone.js timing, event patching assumptions, and implicit change detection behavior without mixing the work into a version hop.

Prepare an Angular app for zoneless execution in bounded post-upgrade modernization slices after Angular 19 is stable. Use when reducing reliance on Zone.js timing, event patching assumptions, and implicit change detection behavior without mixing the work into a version hop.

Prepare an Angular app for zoneless execution in bounded post-upgrade modernization slices after Angular 20 is stable. Use when reducing reliance on Zone.js timing, event patching assumptions, and implicit change detection behavior without mixing the work into a version hop.

Prepare an Angular app for zoneless execution in bounded post-upgrade modernization slices after Angular 21 is stable. Use when reducing reliance on Zone.js timing, event patching assumptions, and implicit change detection behavior without mixing the work into a version hop.

Use this skill when Angular 22 code still needs runtime module creation or legacy NgModule boundaries.

Govern Angular build budgets and prevent silent performance regressions.

Measure Angular performance against Core Web Vitals before making optimization changes.

Use this skill when Angular 22 performance needs to be measured or improved without guessing.

Assess whether a feature or app is ready for zoneless performance-oriented changes.

Prevents Angular performance issues caused by calling component methods or expensive expressions directly from templates.

Evaluates Angular change detection performance and applies OnPush, signals, async pipe, or immutable state patterns only when compatible and justified.

Reduces Angular initial load cost by selecting compatible lazy loading patterns for routes, standalone components, feature modules, and deferrable views.

Optimizes Angular list rendering by using stable identity tracking with trackBy for legacy templates or @for track for modern Angular.

Guides Angular performance work through evidence, measurement, hypothesis, minimal change, and re-measurement before refactoring.

Adopt Angular's NgOptimizedImage for post-upgrade image performance improvements when the app is already stable and the goal is to optimize priority images, preconnects, responsive sizing, and loading behavior in a controlled slice.

Helps improve Angular rendering performance by applying ChangeDetectionStrategy.OnPush only when component data flow supports it.

Audits Angular components, features, or applications for performance risks before recommending targeted optimizations.

Selects the smallest Angular performance skill based on symptoms, available code, detected Angular version, and measured evidence.

Optimizes Angular data transformations by choosing between pure pipes, computed signals, memoization, and precomputed view models.

Reviews Angular RxJS usage for leaks, duplicated requests, nested subscriptions, unnecessary streams, and operator choices that affect performance.

Detects and refactors expensive, impure, or repeated logic in Angular templates into precomputed state, view models, pure pipes, or computed signals.

Prevents unnecessary DOM recreation in Angular lists by using trackBy with *ngFor or track expressions with @for.

Use this skill when Angular 22 async data should be modeled with the production-ready resource APIs.

Use modern functional guards and resolvers with explicit contracts and testable behavior.

Apply lazy loading safely to Angular routes with clear boundaries and validation.

Design route configuration with clean boundaries, lazy loading, and maintainable route metadata.

Test Angular routing, guards, resolvers, and lazy routes with stable patterns and minimal fragility.

Use this skill when Angular 22 changes affect route configuration, guards, redirects, route reuse, or navigation behavior.

Replaces nested RxJS subscriptions with composable operators and lifecycle-safe subscription handling in Angular code.

Designs Angular reactive contracts that expose readonly Observables instead of mutable arrays, public Subjects, writable signals, or copied subscription state.

Triage Angular dependency vulnerabilities by separating real blockers from low-risk advisories.

Govern DomSanitizer usage so bypasses are explicit, justified, and reviewed.

Gate SSR changes with host validation, proxy trust, and server-side security boundaries.

Define a safe policy for storing and rotating auth tokens in Angular applications.

Use this skill when v22 behavior changes could alter the attack surface or create unsafe assumptions around server and template boundaries.

Prevent XSS by keeping templates, bindings, and trusted HTML usage safe and explicit.

Migrate Angular service worker update code to the v13 API shape. Use when applications still rely on available or activated streams and need to use versionUpdates or related update flow changes.

Reviews and refactors Angular services so each service has one bounded responsibility such as API access, state ownership, mapping, validation, permissions, or feature orchestration.

Bridge RxJS and signals with explicit conversion boundaries and lifecycle safety.

Model feature state with signals while keeping derived state and effects separated.

Establish safe signal usage with clear boundaries for state, derivation, and side effects.