Refactoring Agent Skills

Reduces cognitive complexity of a specified method by extracting logic into focused helper methods, improving readability and maintainability.

Analyzes differences between two project versions to generate precise migration instructions for GitHub Copilot, enabling consistent code transformations during technology migrations, refactoring, or framework upgrades.

Discovers all projects in a .NET solution, classifies each for Oracle-to-PostgreSQL migration eligibility, and produces a persistent master migration plan.

Provides React composition patterns to avoid boolean prop proliferation, build flexible component libraries, and design reusable APIs, including React 19 changes.

Optimize React and Next.js applications with 70 performance rules across 8 categories, prioritized by impact for automated refactoring and code generation.

Refactor SwiftUI views toward small, explicit, stable view types with MV data flow, dedicated subviews, and correct Observation usage.

Review and fix Swift Concurrency issues in Swift 6.2+ codebases by applying actor isolation, Sendable safety, and modern concurrency patterns with minimal behavior changes.

Plan and execute large refactor or rewrite efforts efficiently with parallel multi-agent analysis and implementation.

Review git diffs or file scopes for code reuse, quality, efficiency, and clarity issues, then optionally apply safe, behavior-preserving fixes.

Designs complex generic types, refactors `any` types to strict alternatives, creates type guards and utility types, and resolves TypeScript compiler errors.

Write readable, maintainable code through disciplined naming, small functions, and clean error handling.

Structure software around the Dependency Rule so that source code dependencies point inward from frameworks to use cases to entities, keeping business rules independent of databases, UI, and external agencies.

Model software around the business domain using bounded contexts, aggregates, and ubiquitous language, with scoring and diagnostic tools for evaluating domain model quality.

Apply meta-principles of software craftsmanship: DRY, orthogonality, tracer bullets, and design by contract to build systems that are easy to change, understand, and trust.

Apply named refactoring transformations to improve code structure without changing behavior, guided by code smells and safe transformation sequences.

Safely change and test untested codebases using techniques from Feathers' 'Working Effectively with Legacy Code': seams, characterization tests, sprout/wrap, and dependency-breaking.

Coordinate large-scale codebase migrations and multi-file refactors across hundreds of files using batched PRs and CI verification.

Generates type-safe, async-first Python 3.11+ code with full type annotations, mypy strict mode, pytest test suites, and validation via black and ruff.

Writes, debugs, and refactors JavaScript code using modern ES2023+ features, async/await patterns, ESM module systems, and Node.js APIs.

Designs incremental migration strategies, identifies service boundaries, produces dependency maps and migration roadmaps, and generates API facade designs for aging codebases.

Enforces a strict efficiency ladder—YAGNI, reuse, stdlib, native platform, existing deps—before writing any new code, preventing over-engineering and unnecessary dependencies.

Compares two code versions for semantic equivalence by tracing both side-by-side, identifying divergences, and producing a structured verdict.

Identifies, classifies, and prioritizes tech debt to build a refactoring roadmap, drawing on twelve classic engineering books.

Provides patterns and strategies for migrating imperative TypeScript code to fp-ts functional programming patterns, covering error handling, null checks, callbacks, dependency injection, and loops.

Maps a codebase into feature-grouped flowcharts, identifies duplicated concerns across features, and proposes a unified architecture with handoff prompts for refactoring.

Scans classes in a specified package using Spring's ResourcePatternResolver and filters out abstract classes, interfaces, and classes without public constructors.

Migrates C# code from the legacy Nest library (1.x) to version 7.17.5, covering API changes, query syntax refactoring, source filtering, aggregations, and MultiSearch logic.

Scans a codebase for Martin Fowler's catalog of code smells, reporting each with location, severity, and refactoring recommendations, and ranks files to build a prioritized refactoring queue.

Applies the same change across multiple repositories in parallel using git worktrees, tests, and pull requests.

Migrate LWC components from fragile querySelector lookups to typed lwc:ref handles, with guidance on lifecycle timing, shadow boundaries, and iterator limitations.

Redesign Salesforce Flows to handle bulk data loads without hitting transaction limits, using collection-first patterns and safe transaction scope.

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

Write, review, or improve SwiftUI code following best practices for state management, view composition, performance, macOS-specific APIs, and iOS 26+ Liquid Glass adoption. Use when building new SwiftUI features, refactoring existing views, reviewing code quality, or adopting modern SwiftUI patterns.

Find a single insight that eliminates multiple components by recognizing when seemingly different systems share a common underlying pattern.

Guides incremental code improvements, error-proofing through types and validation, and standardization to raise code quality and prevent defects.

Write idiomatic PHP code with generators, iterators, SPL data structures, and modern OOP features. Use proactively for high-performance PHP applications.