Linter-driven refactoring patterns to reduce complexity and improve code quality. Use when linter fails with complexity issues (cyclomatic, cognitive, maintainability) or when code feels hard to read/maintain. Applies storifying, type extraction, and function extraction patterns.
Formatting rules for TypeScript conditional types. Use when writing complex conditional types to ensure debuggable, maintainable formatting with proper alignment.
Architecture and code review guidance for this repo, with RSC boundaries, SOLID, quality gates, and mentoring. Use when reviewing changes or advising design.
Refactor high-complexity React components in Dify frontend. Use when `pnpm analyze-component --json` shows complexity > 50 or lineCount > 300, when the user asks for code splitting, hook extraction, or complexity reduction, or when `pnpm analyze-component` warns to refactor before testing; avoid for simple/well-structured components, third-party wrappers, or when the user explicitly wants testing without refactoring.
Prevents false positive findings by recognizing framework patterns, codebase conventions, and common non-issues. Use when uncertain whether something is a real issue.
Provide structured software code reviews that confirm scope, focus on root causes, evaluate tests, and enforce project conventions.
Provides detailed fix instructions for coding rule violations. Uses the rule index to locate violated rules and extract fix patterns. Use when code violates rules or when the user asks how to fix compliance issues.
Comprehensive code review skill for FastAPI projects. Analyzes codebase against industry best practices covering async patterns, project structure, Pydantic usage, dependency injection, database patterns, testing, and performance. Generates detailed refactor plans with prioritized recommendations. Use when reviewing FastAPI projects, auditing code quality, planning refactors, or ensuring adherence to FastAPI/async best practices.
Perform thorough, constructive code reviews focusing on correctness, security, maintainability, and best practices
Execute lint, test, and build checks before pushing code
Reviews code for quality, security, and maintainability. Use after implementing features, completing significant work, or when user asks for code review.
Use when writing Rails models - enforces state-as-records not booleans, concerns as adjectives namespaced under model, invocation ordering, and private indentation
Run code hygiene checks before committing. Use before git commits or when asked to check code quality.
Review and validate a resource implementation follows all patterns. Use after creating a resource or when refactoring existing code. Triggers on "review resource", "validate resource", "check implementation", "refactor resource".
Fast compliance fixes for design tokens, imports, and common violations
Input validation patterns for the .NET 8 WPF widget host app. Use when implementing form validation, data annotations, command can-execute logic, and error display in MVVM ViewModels.
Validates React code for Rules of Hooks violations. Catches issues like hooks called after conditional returns that cause production crashes (React error
Validates skills against production-level criteria with 9-category scoring. This skill should be used when reviewing, auditing, or improving skills to ensure quality standards. Evaluates structure, content, user interaction, documentation, domain standards, technical robustness, maintainability, zero-shot implementation, and reusability. Returns actionable validation report with scores and improvement recommendations.
Architecture-focused code review. Checks for pattern consistency, separation of concerns, and dependency direction.
Write clean, consistent code following project-wide coding style conventions and formatting standards. Use this skill when writing any code in any language or file type throughout the project. Use this skill when naming variables, functions, classes, or files. Use this skill when organizing code structure and indentation. Use this skill when creating functions and deciding function size and scope. Use this skill when removing dead code, unused imports, or commented-out blocks. Use this skill when applying DRY principles to avoid code duplication. Use this skill when ensuring consistent formatting and style across the codebase. Use this skill when refactoring code for better readability and maintainability.
