1.6K skills · sorted by relevance
Analyze .NET test suites for repeated setup, assertions, and copied test methods. Get a report with file locations, before-and-after refactoring examples, priorities, and readability trade-offs, without changing the source files.
Guide an AI agent through feature development, bug fixes, and refactoring with clear requirements, explained design choices, and small, tested changes. Keep human decisions central while making progress and verification results visible.
Develop features, fix bugs, and refactor code by writing tests before implementation. The workflow combines unit, integration, and end-to-end tests of complete user flows, with an 80% coverage requirement and checks for errors and boundary cases.
Guides performance improvements when writing, reviewing, or refactoring React and Next.js applications. Prioritized rules cover data fetching, bundle size—the amount of code delivered to browsers—and rendering, with explanations and code examples.
Refactor React components that have accumulated many boolean options. Apply component composition, meaning building interfaces from cooperating parts, and shared state patterns to design reusable component libraries and clearer APIs, with guidance specific to React 19.
Work through sixteen open questions in four rounds to clarify major product decisions, risky changes, or large refactors. The agent adapts later questions to earlier answers, then turns your decisions into a step-by-step implementation plan.
Turn a feature or refactoring idea into a concise implementation prompt for another agent. It asks focused questions one at a time, records decisions, and includes development steps, validation, and working rules.
Guide Python module additions and refactoring in APM CLI. Uses existing architecture patterns to organize shared logic and decision ownership, with regression tests and static checks to protect changes that centralize behavior.
Refactor React components into reusable pieces with clearer interfaces. Provides patterns for replacing excessive boolean settings, sharing state through providers, and designing component libraries, with additional guidance for React 19 APIs.
Refactor SwiftUI screens into smaller view types while preserving layout and behavior. Organize state, dependencies, and actions, and check that observable models use the appropriate state wrappers for the app’s supported iOS versions.
Guide feature changes and bug fixes through test-driven development: write a failing test, add the minimum code to pass, then improve the structure. Check coverage and include tests for boundary conditions, errors, and relevant integration points.
Carry a software project from requirements and design through implementation, testing, debugging, and deployment. Tracks progress in files, works through features incrementally, and resumes interrupted development, supporting new projects and broad refactoring efforts.
Design backend systems with clear boundaries between business rules, databases, and external services. Use Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to organize new applications, refactor existing code, and make core logic easier to test.
Investigates existing code before feature work, bug fixes, or refactoring. Finds similar implementations, reusable helpers, naming rules, and data handling patterns so proposed changes follow the project's established conventions.
[omh] Messy or AI-generated code to clean up: delete AI-generated slop, dead code, and duplication while observable behavior stays identical. Use when the user says: ai-slop-cleaner, cleanup, deslop, refactor, risky, behavior-preserving refactor, risk analysis, refactor workflow.
The English summary is being prepared. Showing the original description.
Apply Refactoring.Guru-inspired rules when diagnosing code smells, choosing refactoring techniques, and stopping cleanup before uncontrolled redesign.
The English summary is being prepared. Showing the original description.
Refactor code after tests pass. The "Refactor" phase of Red-Green-Refactor.
The English summary is being prepared. Showing the original description.
Refactor code while preserving passing tests and behavior. Use during the TDD refactor phase to remove duplication, improve design, and verify each structural change.
The English summary is being prepared. Showing the original description.
You are a code refactoring expert specializing in clean code principles, SOLID design patterns, and modern software engineering best practices. Analyze and refactor the provided code to improve its quality, maintainability, and performance.
The English summary is being prepared. Showing the original description.
Review generated or changed production code before it ships, using Clean Code, SOLID, DRY, KISS, YAGNI, and LLM-specific failure-mode checks in any programming language. Best used reactively after an agent writes, edits, refactors, or fixes code, before presenting, committing, or merging the result. Use when the user asks "review this PR", "is this safe to merge?", "make this cleaner", "audit this code", "refactor this", "fix this bug", or after a coding agent produced implementation code. Can also guide writing when explicitly invoked before a risky edit. Invoke it on your own initiative the moment you finish writing, editing, or refactoring non-trivial production code, before presenting or committing — don't wait to be asked. DO NOT USE for factual/conceptual questions, CI/tooling config, git workflow, running/debugging tests, pure architecture discussion, prose writing, data analysis, or test-code review (use test-guard).
The English summary is being prepared. Showing the original description.
Refactor code to improve structure and maintainability
The English summary is being prepared. Showing the original description.
Pre-refactor safety checklist. Verifies test coverage exists before AI modifies existing code. Use before asking AI to refactor anything.
The English summary is being prepared. Showing the original description.
Progressive L1-L6 refactoring hierarchy, 22 code smell taxonomy, atomic transformations, test code smells, and Fowler refactoring catalog
The English summary is being prepared. Showing the original description.
Use when you need to verify Java performance optimizations by comparing profiling results before and after refactoring — including baseline validation, post-refactoring report generation, quantitative before/after metrics comparison, side-by-side flamegraph analysis, regression detection, or creating profiling-comparison-analysis and profiling-final-results documentation. This should trigger for requests such as Verify performance fix; Verify the performance; Verify the memory; Verify the threading; Compare before and after profiling results; Check for performance regressions after refactoring. Part of Plinth Toolkit
The English summary is being prepared. Showing the original description.