912 skills · sorted by relevance
Find business logic repeated across software components, such as notifications, auditing, and validation. Compare responsibilities and dependencies, then recommend a shared service, shared library, or component merger with a prioritized consolidation plan.
Refactor React components that have too many true-or-false settings into reusable, flexible parts. This skill guides component composition, shared state, and API design, with examples and separate guidance for React 19 features.
Investigate unfamiliar codebases before fixing bugs, adding features, or refactoring. Follow relevant code paths, plan focused changes, and verify results, while recording useful discoveries in .notebook/ so later sessions can build on earlier investigation.
Analyze files or modules for duplicated code, excessive complexity, and violations of SOLID, five software design principles. Get prioritized refactoring suggestions with affected locations, risks, estimated effort, and testing needs to guide code improvements.
Save the current code state in a local Git commit before risky changes, then return to that checkpoint if needed. Useful for multi-file refactoring and trying another approach after an unsuccessful edit.
Supports development with code quality and security checks, change impact analysis, documentation templates, and coordination across multiple agents. It defines checkpoints for new modules and refactoring, plus roles and file ownership rules for parallel work.
Analyze code changes to identify affected modules and check whether documentation and tests were updated alongside them. Produce a report on change size, documentation status, and missing updates before committing or after design changes and refactoring.
Check code for complex logic, duplication, naming issues, and oversized functions. Get a quality report with file locations and severity levels, plus guidance on splitting complex code and extracting shared logic during reviews or after refactoring.
Write, review, and refactor React and Next.js code using Vercel's performance guidelines. Apply prioritized rules to reduce sequential data fetching, shrink downloaded code, improve server processing, and avoid unnecessary updates to the interface.
Interpret .NET coverage reports, which show code exercised by tests, to explain missing coverage and stalled progress. Calculate the gains needed to reach a target and, when requested, combine coverage with complexity to rank risk.
Refactor C#/.NET code through renaming, extraction, consolidation, and other structural changes while preserving behavior. Check compatibility beyond code references, including public APIs and serialized names, then validate with builds and relevant tests.
Guides the refactoring of large JavaScript files into smaller CommonJS modules within gh-aw. It covers source placement, function exports, tests, and action builds so extracted code remains testable and is included in generated actions.
Review a codebase for design friction and compare refactoring candidates in an HTML report with before-and-after diagrams. Then explore a chosen candidate through questions about constraints, module design, and testing.
Golang refactoring — safe, at-scale restructuring of existing Go code: a coverage-adaptive safety net, behavior-preserving transforms (gopls Rename/Extract, `gofmt -r`, `gopatch`), the Fowler catalog mapped to Go, breaking import cycles, and small stacked PRs. Apply when a function or type has grown too large, a code smell blocks a feature, or the user asks to refactor Go code — also for renaming at scale, extracting functions or interfaces, moving code between packages, or planning a multi-step refactor. Target styles owned elsewhere → See `samber/cc-skills-golang@golang-naming` (renames), `samber/cc-skills-golang@golang-project-layout` (splits), `samber/cc-skills-golang@golang-modernize` (idioms), `samber/cc-skills-golang@golang-code-style` (control flow), `samber/cc-skills-golang@golang-design-patterns` (patterns/DI).
The English summary is being prepared. Showing the original description.
Apply Martin Fowler-inspired refactoring rules when improving existing code structure while preserving observable behavior.
The English summary is being prepared. Showing the original description.
Safely change and test untested codebases using Feathers' "Working Effectively with Legacy Code". Use when the user mentions "legacy code", "no tests", "untested codebase", "how do I test this", "seams", "characterization tests", "golden master", "sprout method", "afraid to change this code", "monster method", "dependency breaking", or "inherited a messy codebase". Also trigger when changing code without tests safely, getting a class under test when constructors, statics, or singletons block it, adding features to tangled modules, or planning incremental test coverage for an old codebase. Covers the legacy-code change algorithm, seams, characterization tests, sprout/wrap, and dependency-breaking techniques. For refactoring code that already has tests, see refactoring-patterns. For day-to-day code quality, see clean-code.
The English summary is being prepared. Showing the original description.
Write readable, maintainable code through disciplined naming, small functions, and clean error handling. Use when the user mentions "clean up this code", "this function is too long", "code smells", "naming conventions", "boy scout rule", "single responsibility", or "unit test quality". Also trigger when reviewing a pull request for readability, untangling a messy function, debating comment styles, or improving error-handling patterns. Covers SRP, comment discipline, formatting, and unit testing. For refactoring techniques, see refactoring-patterns. For architecture and dependency rules, see clean-architecture.
The English summary is being prepared. Showing the original description.
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", "avoid technical debt", "code ownership", or "how do I become a better developer". 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.
The English summary is being prepared. Showing the original description.
Guided journey from a working-but-untested vibe-coded prototype to a production-ready product with tests, clean structure, a business-rules boundary, and resilience at scale. Orchestrates nine skills phase by phase - working-with-legacy-code, clean-code, refactoring-patterns, software-design-philosophy, clean-architecture, pragmatic-programmer, release-it, system-design, ddia-systems - asking the user questions at every decision point and recording results in the project docs/ folder (TESTING.md, TECH-DEBT.md, IMPROVE-CODE-QUALITY-PLAN.md) so the journey resumes across sessions. Use when the user wants to harden an AI-generated prototype, add tests before refactoring, make code safe to change, or says 'this works on my machine but I am scared to touch it'. For an aged codebase, remove-technical-debt; for greenfield structure, design-code-architecture; for a product and UX pass, improve-app; to optimize speed and structure, architecture-optimization. For one framework in isolation, invoke that skill directly.
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.
**UTILITY SKILL** - Explain code snippets, functions, and algorithms in plain language. USE FOR: explain code, what does this code do, break down this function, help me understand this, walk through this algorithm, clarify this logic, explain this snippet, describe what happens here. DO NOT USE FOR: writing new code (use code generation), fixing bugs (use debugging), refactoring (use refactoring skills), code review with action items. INVOKES: file reading tools to access code, language detection for tailored explanations. FOR SINGLE OPERATIONS: If the user just needs to see file contents, use file reading tools directly.
The English summary is being prepared. Showing the original description.
Generates tests that capture current behavior of existing code before refactoring. Use when you need a safety net before AI-assisted refactoring or modifying legacy code.
The English summary is being prepared. Showing the original description.
Detailed refactoring mechanics with step-by-step procedures, and test code smell catalog with detection patterns and before/after examples
The English summary is being prepared. Showing the original description.
DDD-guided legacy refactoring patterns -- strangler fig, bubble context, ACL migration, 14 tactical/strategic/infrastructure patterns, and incremental monolith-to-microservices methodology
The English summary is being prepared. Showing the original description.