Results for “refactoring”

Practical UI refactoring and visual design review inspired by Refactoring UI by Steve Schoger and Adam Wathan. Use when an AI coding agent needs to improve an existing interface, audit visual polish, redesign a rough UI, review frontend code for hierarchy/spacing/typography/color/depth/image issues, or turn a plain implementation into a cleaner product-quality screen. Do not use for creating UI from scratch, scaffolding a new app, building a new landing page, or designing a new design system unless the user explicitly asks to review or refactor an existing interface.

The English summary is being prepared. Showing the original description.

Code refactoring strategies, technical debt reduction, architecture modernization, and code quality improvement. Use when refactoring code, modernizing legacy code, reducing complexity, or improving maintainability.

The English summary is being prepared. Showing the original description.

Review a codebase for structural problems that make understanding and testing difficult. Compare refactoring candidates in an HTML report with before-and-after diagrams, then explore the chosen option through questions about constraints, design, and tests.

• Review architecture in frequently changed code
• Compare refactoring options with before-and-after diagrams
• Explore module designs that are easier to test

Apply shared coding conventions to new modules, reviews, and refactoring. Guides descriptive naming, readable structure, updates that preserve existing data, and error handling, giving teams a consistent basis for checking code quality.

• Setting coding conventions for a new project
• Reviewing code readability and maintainability
• Refactoring duplication and deeply nested logic

Develop Spring Boot features and fixes by writing tests before implementation. Guides unit, web, persistence, and integration testing with JUnit 5, Mockito, MockMvc, and Testcontainers, plus JaCoCo measurement of how much code tests cover.

• Adding Spring Boot endpoints with tests first
• Writing regression tests for bug fixes
• Testing database persistence and retrieval

Develop and refactor Quarkus 3.x LTS services by writing tests first. Covers API responses, event handling, and asynchronous operations, with unit and integration tests plus coverage checks to show how much code is tested.

• Adding REST endpoints with tests first
• Reproducing bugs before fixing them
• Testing Apache Camel routes and event handling

Verify Quarkus services before pull requests or deployment through builds, code analysis, tests, coverage reports, and security scans. The workflow also checks native executables, containers, performance, health endpoints, configuration, and documentation.

• Checking a Quarkus service before a pull request
• Verifying refactoring or dependency upgrades
• Checking native executable compatibility

Write, review, and refactor modern C++ using the C++ Core Guidelines. Covers type safety, automatic resource cleanup, class design, exceptions, concurrency, and naming conventions, with examples and a checklist for identifying unsafe or inconsistent code.

• Writing modern C++ classes and functions
• Reviewing memory ownership and resource cleanup
• Refactoring existing C++ code

Review how easy code is to maintain using CodeScene MCP. Compare structural health scores before and after edits, identify design issues, and check commits and pull requests for changes that reduce maintainability.

• Reviewing an unfamiliar file before editing
• Checking whether AI edits reduce maintainability
• Refactoring while comparing health scores

Delegate feature development, refactoring, and pull request reviews to Grok Build CLI. Use single-task runs or interactive sessions, monitor longer jobs, and resume earlier work with the project's existing instructions.

• Delegating a feature implementation
• Refactoring existing code
• Reviewing pull request changes

Delegate feature implementation, refactoring, and pull request reviews to OpenCode CLI, a command-line AI coding agent. Run bounded tasks or ongoing sessions, monitor progress, resume work, and report file changes and test results.

• Delegate feature implementation and refactoring
• Review pull requests for bugs and missing tests
• Monitor and resume long coding sessions

Guides delegation of coding tasks to Claude Code CLI through Hermes. Covers one-shot runs and ongoing interactive sessions for feature work, bug fixes, refactoring, and reviews, with controls for tool permissions, execution limits, and structured results.

• Delegating feature implementation or bug fixes
• Reviewing code changes and pull requests
• Iterating on refactoring and tests

Delegate feature development, code refactoring, and pull request reviews to OpenAI Codex CLI. The skill also covers monitoring long tasks and fixing multiple issues in parallel using separate Git working directories.

• Adding a feature to an existing project
• Refactoring an authentication module
• Reviewing proposed code changes

Guide coding, reviews, and refactoring with explicit assumptions, simple implementations, focused changes, and testable goals. These behavioral guidelines help an AI agent avoid unnecessary complexity and verify that its changes meet the request.

• Clarifying assumptions before implementation
• Keeping bug fixes focused
• Reviewing code for unnecessary complexity

Make working code easier to read and maintain while preserving its behavior. The skill identifies tangled conditions, unclear names, duplication, and unnecessary abstractions, then guides small refactoring steps checked against existing tests and project conventions.

• Improving readability after a feature is working
• Addressing complexity raised in code review
• Untangling nested conditions and long functions

Improve existing code through repeated cycles of testing, implementation, and refactoring. The skill covers performance bottlenecks, error recovery, code coverage, and documentation, helping developers refine behavior and structure while keeping tests passing.

• Refactoring existing code while keeping tests passing
• Adding tests before implementing expected behavior
• Investigating slow database access and cache usage

Review source code for readability, complexity, duplication, and maintainability without changing files. Receive a structured report with prioritized issues, refactoring suggestions, positive findings, and estimates of technical debt—the work needed to address accumulated code problems.

• Review the quality of an authentication module
• Find duplicate code and overly long methods
• Assess accumulated code problems and repair effort

Turn software development goals into manageable milestones with clear deliverables, dependencies, effort estimates, and success criteria. Use it to plan feature implementation, bug fixes, refactoring, performance improvements, and testing work.

• Planning OAuth2 authentication implementation
• Setting measurable database performance targets
• Breaking refactoring into incremental steps

Review a codebase for readability, performance, security, and architectural issues. The skill organizes findings into actionable recommendations, helping teams identify refactoring work, dependency risks, and areas that need better tests.

• Reviewing code quality before a pull request is merged
• Investigating performance and security issues
• Prioritizing refactoring and dependency updates

Connect agent tasks in sequence, passing each result into the next step. Build custom workflows or use predefined pipelines for code analysis, refactoring, testing, and optimization, with execution progress, timing, and consolidated results.

• Turn code analysis into an improvement plan
• Prioritize and carry out refactoring
• Find test gaps and generate unit tests

Refactor React components with too many true-or-false options into reusable parts. Provides guidance on component composition, shared state, and flexible interfaces, with examples of good and problematic implementations and specific guidance for React 19.

• Refactoring components with too many boolean options
• Designing reusable component libraries
• Reviewing shared state and component architecture

Write, review, and refactor React and Next.js code using performance guidelines from Vercel. Prioritized rules help identify sequential data requests, oversized JavaScript bundles, unnecessary re-renders, and other opportunities to improve loading and responsiveness.

• Reviewing React components for performance issues
• Improving data fetching in Next.js pages
• Reducing JavaScript bundle size

Write, review, or refactor React and Next.js code using prioritized performance guidelines. Address sequential data requests, large bundles of browser code, server work, and unnecessary rendering, with explanations and code examples for each rule.

• Writing React components with performance in mind
• Reviewing Next.js data fetching
• Reducing browser code size and loading time

Guide Angular development, code review, and refactoring with prioritized performance rules. Review rendering efficiency, loading time, and bundle size—the amount of code delivered to browsers—alongside data fetching and server-rendered page setup.

• Writing Angular components with performance in mind
• Reviewing code for performance bottlenecks
• Reducing bundle size and loading time