Results for “refactoring”

Python design patterns including KISS, Separation of Concerns, Single Responsibility, and composition over inheritance. Use when making architecture decisions, refactoring code structure, or evaluating when abstractions are appropriate.

Delivers changes incrementally by building in thin vertical slices, testing and verifying each piece before moving to the next.

Enforce idiomatic Rust patterns for ownership, error handling, enums, traits, concurrency, and best practices to build safe, performant applications.

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

Guides minimal-diff code changes by defining contracts and invariants, choosing a stable seam, and proving the result with an executed check.

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

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

Implements features, fixes bugs, and refactors code by orchestrating domain-specific skills, following existing patterns, and verifying tests and lint pass.

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

Write idiomatic Elixir code with OTP patterns, supervision trees, and Phoenix LiveView. Masters concurrency, fault tolerance, and distributed systems. Use PROACTIVELY for Elixir refactoring, OTP design, or complex BEAM optimizations.

Refactor legacy codebases, migrate outdated frameworks, and implement gradual modernization. Handles technical debt, dependency updates, and backward compatibility. Use PROACTIVELY for legacy system updates, framework migrations, or technical debt reduction.

Apply meta-principles of software craftsmanship: DRY, orthogonality, tracer bullets, and design by contract. Use when the user mentions "best practices", "pragmatic approach", "broken windows", "tracer bullet", "software craftsmanship", "technical debt prevention", "prototype vs tracer bullet", or "code ownership". Also trigger when evaluating build-vs-buy decisions, designing estimation approaches, or choosing between reversible and irreversible architectural decisions. Covers estimation, domain languages, and reversibility. For code-level quality, see clean-code. For refactoring techniques, see refactoring-patterns.

Transforms working code into clean, readable, and maintainable code following Robert C. Martin's principles.

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

Delegate coding tasks such as feature building, refactoring, and PR reviews to OpenAI's Codex CLI, with support for background execution and parallel worktrees.

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

Assists with software engineering tasks including writing, editing, and explaining code, searching codebases, running commands, managing files, debugging, and implementing features.

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

Write idiomatic C++ code with modern features, RAII, smart pointers, and STL algorithms. Handles templates, move semantics, and performance optimization. Use PROACTIVELY for C++ refactoring, memory safety, or complex C++ patterns.

Write idiomatic Ruby code with metaprogramming, Rails patterns, and performance optimization. Specializes in Ruby on Rails, gem development, and testing frameworks. Use PROACTIVELY for Ruby refactoring, optimization, or complex Ruby features.

Write idiomatic C++ code with modern features, RAII, smart pointers, and STL algorithms. Handles templates, move semantics, and performance optimization. Use PROACTIVELY for C++ refactoring, memory safety, or complex C++ patterns.

Write idiomatic Ruby code with metaprogramming, Rails patterns, and performance optimization. Specializes in Ruby on Rails, gem development, and testing frameworks. Use PROACTIVELY for Ruby refactoring, optimization, or complex Ruby features.

Conducts multi-axis code review across correctness, readability, architecture, security, and performance before merging any change.

Audit and fix visual hierarchy, spacing, color, and depth in web UIs using a systematic, opinionated design framework.

Manage software complexity through deep modules, information hiding, and strategic programming, with a scoring framework for evaluating design quality.

Analyzes code diffs and files to identify bugs, security vulnerabilities, code smells, and architectural concerns, producing a structured review report with prioritized, actionable feedback.

Refactors code by removing unused imports, variables, methods, redundant comments, and fixing formatting, with automatic test runs and commits after each step.

Systematically explore an unfamiliar codebase and build a reusable architecture summary with file:line evidence, starting from documentation and tracing data flow.

Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: "Rename this function", "Extract this into a module", "Refactor this class", "Move this to a separate file"

Systematically repair a broken feature or module by scoping, tracing dependencies, diagnosing all issues, fixing them in order, and verifying end-to-end.

Restructure code while preserving behavior: confirm tests are green, refactor in small steps, keep tests green, review, and commit with a gated workflow.

Organizes 70+ React and Next.js performance optimization rules across 8 priority categories for use when writing, reviewing, or refactoring code.

Migrate Pester v5 classic Should -Be assertion syntax to the new Pester v6 Should-* operators with a step-by-step mapping and behavioral gotchas.

Reviews code through the lens of 12 classic software engineering books, catching design smells, coupling issues, and architectural risks that linters miss.

Extreme Programming for AI-human pair development. Use when: pair programming with your AI, building incrementally with tests, working with clear role division, or the user mentions XP/YAGNI/simple design/continuous refactoring.

Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: "Rename this function", "Extract this into a module", "Refactor this class", "Move this to a separate file"