Refactoring Agent Skills

Apply modern Perl 5.36+ idioms, best practices, and conventions for building robust, maintainable applications.

Provides idiomatic C# and .NET patterns covering immutability, dependency injection, async/await, options, result, repository, middleware, and minimal API conventions for building maintainable applications.

Enforces idiomatic Kotlin conventions across null safety, immutability, sealed hierarchies, coroutines, extension functions, DSL builders, and Gradle Kotlin DSL.

Optimizes React and Next.js performance with 70+ rules across 8 priority categories, covering waterfalls, bundle size, server-side, client fetching, re-renders, rendering, JS micro-perf, and advanced patterns. Use when writing, reviewing, or refactoring React/Next.js code.

Delivers a small, bounded code change through inspection, a mini-plan, implementation, testing, review, and adversarial verification. Use for bug fixes, configuration changes, and features expected to touch no more than five files.

Reviews a codebase for structural smells and refactors them with provable safety, using micro commits and green-bar discipline.

Reviews and repairs risky or unclear code with minimal validated changes, running a fixed-point loop until the diff is clean across two consecutive review cycles.

Mines a codebase for evidence-backed improvement opportunities, forcing two escalation gates to surface breakthrough ideas, and outputs a ranked portfolio with a plan seed without implementing.

Refactors test files to improve behavioral coverage, clarity, structure, assertions, fixture setup, and mocking strategy, removing implementation-detail or low-value tests.

Refactors code by renaming variables, methods, classes, and types to improve clarity and intent, with automatic testing and commits after each rename.

Refactors long methods or large code blocks by extracting small, focused helper methods with clear names and narrow responsibilities.

Refactors Swift code toward declarative functional programming with immutability, value types, pure functions, transformations, and closure-based APIs.

Optimizes React and Next.js performance with 69 prioritized rules covering waterfalls, bundle size, server-side rendering, and re-rendering patterns.

Migrates a Stitch screen to production React: fetches and caches wireframes, archives existing pages, converts to shadcn/ui components with semantic tokens, and documents the design system layers.

Applies universal TypeScript, JavaScript, React, and Node.js quality conventions for this repo. Use when reviewing or writing TS/TSX, refactoring for clarity, or enforcing naming, immutability, and error-handling patterns.

Runs and interprets Elixir/Phoenix tooling (mix test, credo, dialyzer, format), generates OTP-conforming modules, and helps with Ecto and LiveView patterns.

Converts human-written CLAUDE.md files into a structured-label format that AI models follow more reliably while using fewer tokens.

Write idiomatic Ruby code with metaprogramming, Rails patterns, and performance optimization. Specializes in Ruby on Rails, gem development, and testing frameworks.

Find a unifying insight that eliminates multiple components, collapsing complexity by abstracting common patterns.

Query a pre-indexed codebase via CLI to understand structure, find symbols, assess change impact, debug failures, and evaluate PR risk.

Scans recently changed code for tech debt: duplicated logic, dead code, magic numbers, deep nesting, and TODOs, then proposes fixes.

Improves code readability and maintainability by applying SOLID principles, meaningful naming, small functions, proper error handling, and DRY practices.

Identifies common software anti-patterns in code and suggests refactoring solutions to improve code quality.

Migrate test files from `as` type assertions to @total-typescript/shoehorn, using fromPartial and fromAny for partial or intentionally wrong test data.

Migrate TypeScript test code from `as` assertions to type-safe `shoehorn` helpers like `fromPartial` and `fromAny`.

Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests when writing features, fixing bugs, or refactoring code.

Applies four disciplined mindsets—audit, debt, help, review—to cut complexity, track deferrals, surface reference, and catch over-engineering in codebases.

Design and review native DTOs in WordPress plugins without better-data, covering immutable data carriers, explicit hydration, strict coercion, WP_Error validation, sensitive-field handling, and layer boundaries.

Runs three parallel reviewers to find code reuse, quality, and efficiency issues in a diff, then applies safe fixes and reports risky ones.

Enforces principal-engineer-level Python code quality: formatting, type safety, idiomatic patterns, class and function design, and anti-pattern prevention.

Enforces system design, project structure, dependency management, error handling, testing, and documentation standards at principal-engineer level.

Enforces complexity analysis, correct data structure selection, vectorization, and algorithm implementation discipline at principal-engineer level.

Guides test-first development with vertical slices, one test at a time, and refactoring after green.

Keeps AI coding agents tightly scoped by enforcing minimal changes, simplest solutions, and asking before expanding scope or adding dependencies.

Guides incremental code improvements, error-proofing through types and validation, and standardization for higher quality and fewer defects.

Enforces an algorithm-first discipline: state Big-O, data structure, and algorithm family before writing loops, queries, or recursion, catching O(n^2), N+1, and brute-force defaults.