Loading...
Loading...
Found 631 Skills
Comprehensive coding standards and best practices for maintainable, consistent software development across multiple languages and paradigms
Use when restructuring existing code without changing observable behavior, especially when a feature or bug fix is hard because the current design is awkward, duplicated, confusing, or risky to modify.
Audits code for design pattern opportunities and anti-patterns — identifies places where a specific GoF or architectural pattern would solve an observable problem, and flags misapplied patterns that add complexity without benefit. Generates fix prompts. Trigger phrases: "design patterns", "pattern check", "pattern review", "refactoring patterns", "pattern analysis".
Find dead code and cleanup candidates such as unused exports, unreachable branches, orphaned files, stale feature flags, dead registrations, and compatibility layers with no live callers. Use when auditing refactors, bundle-size cleanup, architecture simplification, pre-release cleanup, reviewing requests to find unused code or decide what can be deleted, or when deciding whether code can be safely removed or auto-fixed.
Analyze Go function lengths within a workspace and generate statistics (p50, p90, p99). Use when you need to audit function complexity, identify long functions, or generate code metrics for Go projects. Only analyzes files matching **/*.go within the current workspace, excluding dependencies.
This skill should be used when making design decisions, evaluating trade-offs, assessing code quality, or when "engineering judgment" or "code quality" are mentioned.
Use when working with tdd workflows tdd refactor
Dead Code Cleanup and Consolidation Expert. Used to remove unused code, duplicate code, and refactor. Execute analysis tools (knip, depcheck, ts-prune) to identify and safely remove dead code.
This skill should be used when analyzing technical debt in a codebase, documenting code quality issues, creating technical debt registers, or assessing code maintainability. Use this for identifying code smells, architectural issues, dependency problems, missing documentation, security vulnerabilities, and creating comprehensive technical debt documentation.
Implement the minimal code needed to make failing tests pass in the TDD green phase.
Core engineering principles for sustainable, maintainable code. No shortcuts, no hacks. Quality gates before completion.
Diagnoses what makes code complex and why, using the three-symptom two-root-cause framework. Use when code feels harder to work with than it should but the specific problem is unclear. This skill identifies WHETHER complexity exists and WHERE it comes from. Not for scanning a checklist of known design smells (use red-flags) or evaluating a specific module's depth (use deep-modules).