Results for “refactoring”

Update an existing implementation plan file with new or updated requirements for features, refactoring, package upgrades, design, architecture, or infrastructure.

Runs three parallel reviewer agents over recent code changes, aggregates their findings, and applies the fixes worth applying.

Enforces dense, correct, and idiomatic code on all coding tasks, minimizing code bloat and agent operation overhead.

Creates a concrete, multi-phase plan before starting a multi-file refactor, including affected files, dependencies, verification steps, and rollback procedures.

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

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

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

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

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

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

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

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 code quality.

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.

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.

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.

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

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.

Drive development with tests by writing a failing test before implementing code, and reproduce bugs with tests before fixing them.

Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests for new features, bug fixes, or refactoring.

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

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

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

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