Claude Skills by NoaiRox

Use when adding a new UI component to an existing module - handles templates, inputs, and test scaffolding.

Use when adding a signal-based store or utility service - creates injectable with inject() and Angular Signals.

Use when creating a new feature module with all layers - service, adapter, types, state, components, and tests.

Use when adding API integration to a module - creates types, contracts, adapter, and service layer.

Use when a module needs test coverage - creates tests for adapters, services, and components.

Use when integrating with an API endpoint and need TypeScript types, contracts, and adapters generated automatically.

Use when onboarding onto a module and need a quick summary of its structure, patterns, and key files.

Use when a component needs migration to the target architecture or framework version.

Use when a complete module needs migration to the target architecture - runs 6 phases with approval gates.

Use when checking if code follows ARCHITECTURE.md patterns - runs automated conformance checks.

Use when architecture violations were found and need automated fixing by priority.

Use when code changes need review before merge - validates architecture, types, security, and test coverage.

Use when adding an interactive UI component that requires client-side JavaScript - creates a framework island with hydration strategy.

Use when adding server state management to a module - creates React Query hook with caching and error handling.

Use when adding server state management or shared logic - creates an auto-imported composable with useFetch/useAsyncData.

Use when adding state management to a module - creates Svelte store with server state integration.

Use when you need a comprehensive code audit covering security, performance, architecture, and dependencies before a release, major refactor, or compliance review.

Use when starting a complex feature, exploring unclear requirements, or needing to challenge assumptions before committing to a design - before /plan.

Use when about to start risky changes, before major refactors, or when you need a safe rollback point during multi-step implementations.

Use when you need a comprehensive code review combining architecture, security, and test perspectives - especially before merging, releasing, or after major changes.

Use when changes are ready to commit - generates conventional commit messages with scope detection and validation.

Use when encountering any bug, test failure, unexpected behavior, or error - before proposing fixes. Use especially when previous fix attempts have failed.

Use when planning a feature and need to understand token cost, time estimate, or complexity before committing to implementation.

Use when feature implementation is complete and the branch is ready for final validation, PR creation, or merge.

Use when assessing overall project quality, onboarding onto a new codebase, or before major refactoring to establish a baseline.

Use when implementing a feature and want to understand the code as it's built - during onboarding, teaching, or learning a new pattern.

Use when you need to lint the codebase and auto-fix issues - detects linter, runs it, and fixes what it can.

Use when transforming a project's architecture pattern - e.g., Flat to Modular, MVC to Clean Architecture, Monolith to Modular Monolith.

Use when switching a project or component between frameworks - React to Vue, Vue to Svelte, or any supported framework pair.

Use when joining an unfamiliar codebase, starting on a new team, or needing to understand a project's architecture, conventions, and key modules quickly.

Use when starting a new feature, refactor, or multi-step task - before writing any code. Use especially when scope is unclear or multiple files are involved.

Use when you need to retrieve a past decision, preference, or convention that was saved with /remember.

Use when making a decision, choosing a convention, or learning a lesson that should persist across sessions.

Use when implementing any feature or bugfix where correctness matters - before writing implementation code.

Use when first using Specialist Agent, onboarding a new team member, or wanting to explore available agents and skills.

Use when about to claim work is complete, fixed, or passing - before committing, creating PRs, or moving to next task. Requires running verification commands and confirming output before making any success claims.

Use when you need workspace isolation for parallel tasks, risky changes, or multi-feature development without branch switching.

Use when creating a new skill, editing an existing skill, or verifying a skill works before deployment.

Use when [specific triggering conditions - what symptom or situation activates this skill]