Refactoring
Code restructuring and optimization
refactoring-guide
by peopleforrester
Safe refactoring patterns and techniques. Use when the user wants to improve code structure, reduce duplication, or make code more maintainable without changing behavior. Emphasizes incremental changes with test coverage.
customer-journey-map
by alunadev
"Maps the end-to-end customer experience from awareness to advocacy — touchpoints, emotions, friction points, and improvement opportunities per stage. Use when identifying drop-off points, improving onboarding, or understanding the full user lifecycle. Triggers on: customer journey, user journey, journey map, touchpoints, onboarding experience, funnel analysis, churn points, aha moment, drop-off, user lifecycle."
TDD Workflow
by ShunsukeHayashi
Test-Driven Development workflow for Miyabi. Red-Green-Refactor cycle with Rust-specific patterns. Use when implementing new features, fixing bugs, or writing tests.
TDD Workflow
by ShunsukeHayashi
Test-Driven Development workflow for Miyabi. Red-Green-Refactor cycle with Rust-specific patterns. Use when implementing new features, fixing bugs, or writing tests.
magento-environment-engineer
by maxnorm
Manages Magento 2 environments including development, staging, and production. Use when setting up environments, configuring servers, managing environments, or troubleshooting environment issues. Masters environment configuration, server management, and environment optimization.
unity-performance
by creator-hian
Optimize Unity game performance through profiling, draw call reduction, and resource management. Masters batching, LOD, occlusion culling, and mobile optimization. Use for performance bottlenecks, frame rate issues, or optimization strategies.
photo-learning
by Hmbown
Recognize a photo and narrate a kid-friendly explanation using image understanding + TTS.
complexity-analyzer
by CuriousLearner
Measure and report code complexity metrics with actionable recommendations.
refactor-assistant
by CuriousLearner
Automated code refactoring suggestions and implementation.
swift-api-design-guidelines-skill
by Erikote04
Write, review, or improve Swift APIs using Swift API Design Guidelines for naming, argument labels, documentation comments, terminology, and general conventions. Use when designing new APIs, refactoring existing interfaces, or reviewing API clarity and fluency.
java-maven-helper
by CuriousLearner
Maven build system, dependency management, and Java project configuration assistance.
music-promo-pack
by Hmbown
Generate a short music clip with cover art and an optional voice tag.
web-ui-design-guide
by muheun
Apply modern, professional web UI design principles when building any web UI component. Only execute this when the current project is a web project and involves UI-related work. Use this skill for UI tasks involving buttons, forms, cards, layouts, navigation, or any visual web component. Ensures clean minimal design, neutral color palettes with single accent color, 8px grid spacing, clear typography hierarchy, and subtle visual effects. Prevents common anti-patterns like rainbow gradients, tiny text, and inconsistent spacing.
humanizer-workbench
by aprempeh-tech
```
applying-effective-go
by MrPointer
"Apply Go best practices, idioms, and conventions from golang.org/doc/effective_go. Use when writing, reviewing, or refactoring Go code to ensure idiomatic, clean, and efficient implementations."
writing-en
by vadirn
Writes and edits English text for clarity and concision. Removes nominalizations, passive voice, filler, and AI patterns. Use when writing documentation, README, commit messages, UI text, reports, emails, or when asked to simplify text, cut fluff, or check for plain language.
gof-design-patterns
by emvnuel
Detects opportunities to apply GoF Design Patterns in Jakarta EE/MicroProfile. Use when reviewing code for structural improvements or implementing creational, structural, or behavioral patterns.
applying-architecture-patterns
by MrPointer
Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use when (1) designing new backend systems from scratch, (2) refactoring monolithic applications for better maintainability, (3) establishing architecture standards for a team, (4) migrating from tightly coupled to loosely coupled architectures, (5) implementing domain-driven design principles, (6) creating testable and mockable codebases, or (7) planning microservices decomposition.
TDD Skill
by vadirn
Mock at system boundaries only: external APIs, databases, time, filesystem. Keep mocks out of your own code. See mocking.md for details.
youtube-downloader
by cdeistopened
Download YouTube video transcripts when user provides a YouTube URL or asks to download/get/fetch a transcript from YouTube. Also use when user wants to transcribe or get captions/subtitles from a YouTube video.
anti-ai-writing
by cdeistopened
Transform AI-assisted drafts into authentic, human-sounding content. This skill provides patterns to detect and eliminate AI tells, frameworks for natural writing, and techniques for creating prose that reads as genuinely human. Use when reviewing any AI-generated content or when writing content that must not appear AI-assisted.
rotz-dotfiles
by gwenwindflower
Use when working with a rotz-based dotfiles repository. This includes: (1) Managing tools or apps (adding, configuring, or removing), (2) Modifying rotz configuration files (dot.yaml, defaults.yaml, config.yaml), (3) Updating tool configurations managed by rotz (mise.toml, config.fish, etc.), (4) Restructuring the dotfiles hierarchy, (5) Planning architectural changes to the dotfiles project.
docs-generator
by Montimage
Restructure project documentation for clarity and accessibility. Use when users ask to "organize docs", "generate documentation", "improve doc structure", "restructure README", or need to reorganize scattered documentation into a coherent structure. Analyzes project type and creates appropriate documentation hierarchy.
architecture-patterns
by xfstudio
Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use when architecting complex backend systems or refactoring existing applications for better maintainability.