shell-error-handling
Use when implementing error handling, cleanup routines, or debugging in shell scripts. Covers traps, exit codes, and robust error patterns.
shell-portability
Use when writing shell scripts that need to run across different systems, shells, or environments. Covers POSIX compatibility and platform differences.
shell-scripting-fundamentals
Use when writing or modifying Bash/shell scripts. Covers script structure, variables, quoting, conditionals, and loops with modern best practices.
shell-best-practices
Use when writing shell scripts following modern best practices. Covers portable scripting, Bash patterns, error handling, and secure coding.
shfmt-configuration
Use when configuring shfmt for shell script formatting including .shfmt.toml setup, EditorConfig integration, and project-specific settings.
shfmt-formatting
Use when formatting shell scripts with shfmt. Covers consistent formatting patterns, shell dialect support, common issues, and editor integration.
baseline-restorer
Use when multiple fix attempts fail and you need to systematically restore to a working baseline and reimplement instead of fixing broken code.
fastapi-dependency-injection
Master FastAPI dependency injection for building modular, testable APIs.
Kotlin DSL Patterns
Use when domain-specific language design in Kotlin using type-safe builders, infix functions, operator overloading, lambdas with receivers, and patterns for creating expressive, readable DSLs for configuration and domain modeling.
Kotlin Null Safety
Use when kotlin's null safety system including nullable types, safe calls, Elvis operator, smart casts, and patterns for eliminating NullPointerExceptions while maintaining code expressiveness and clarity.
Lua C Integration
Use when lua C API for extending Lua with native code including stack operations, calling C from Lua, calling Lua from C, creating C modules, userdata types, metatables in C, and performance optimization techniques.
Lua Coroutines
Use when lua coroutines for cooperative multitasking including coroutine creation, yielding and resuming, passing values, generators, iterators, asynchronous patterns, state machines, and producer-consumer implementations.
git-storytelling-commit-messages
Use when writing commit messages that clearly communicate changes and tell the story of development. Helps create informative, well-structured commit messages that serve as documentation.
monorepo-architecture
Use when designing monorepo structure, organizing packages, or migrating to monorepo architecture with architectural patterns for managing dependencies and scalable workspace configurations.
code-annotation-patterns
Use when annotating code with structured metadata, tags, and markers for AI-assisted development workflows. Covers annotation formats, semantic tags, and integration with development tools.
documentation-linking
Use when creating bidirectional links between code and documentation. Covers link patterns, documentation references, context preservation across artifacts, and maintaining synchronization between code and docs.
notetaker-fundamentals
Use when leaving structured notes, comments, and annotations in code. Covers AI note-taking patterns, TODO formats, context preservation, and development breadcrumbs for future AI assistants and human developers.
runbooks-incident-response
Use when creating incident response procedures and on-call playbooks. Covers incident management, communication protocols, and post-mortem documentation.
runbooks-structure
Use when creating structured operational runbooks for human operators. Covers runbook organization, documentation patterns, and best practices for clear operational procedures.
absinthe-schema
Use when designing GraphQL schemas with Absinthe. Covers type definitions, interfaces, unions, enums, and schema organization patterns.
validate
Validate checklist items for a ClickUp task without changing status
figma-analyze-frame
Analyze a Figma frame's structure, properties, and implementation considerations
figma-extract-tokens
Extract design tokens and variables from a Figma file to create or update a design system
figma-generate-component
Generate production-ready code from a Figma component or frame using the Figma MCP server
figma-sync-design-system
Sync design system components between Figma and code using Code Connect mappings
create-issue
Create a new issue in a GitHub repository
professional-honesty
Use when responding to questions or providing information requiring professional honesty and directness over excessive agreeableness.
plugin-development
Use when creating or modifying Han plugins. Covers plugin structure, configuration, hooks, skills, and best practices.
architect
Design system architecture and high-level technical strategy
boy-scout-rule
Use when modifying existing files, refactoring, improving code quality, or touching legacy code by applying the Boy Scout Rule to leave code better than you found it.
code-review
Code review a pull request
debug
Investigate and diagnose issues without necessarily fixing them
develop
Comprehensive 8-phase workflow for developing new features with quality enforcement
document
Generate or update documentation for code, APIs, or systems
explain
Explain code, concepts, or technical decisions in clear, understandable terms
fix
Debug and fix bugs, errors, or unexpected behavior
legacy-code-safety
Use when modifying, removing, or refactoring code that lacks test coverage. Emphasizes the danger of untested changes and the RGR workflow to add characterization tests before modifications.
optimize
Optimize code for performance, readability, or efficiency
orthogonality-principle
Use when designing modules, APIs, and system architecture requiring independent, non-overlapping components where changes in one don't affect others.
plan
Create tactical implementation plan for a feature or task
project-memory
Use when setting up or organizing Claude Code project memory (CLAUDE.md, .claude/rules/) for better context awareness, consistent behavior, and project-specific instructions.
proof-of-work
Use automatically during development workflows when making claims about tests, builds, verification, or code quality requiring concrete evidence to ensure trust through transparency.
refactor
Restructure code to improve quality without changing behavior
review
Multi-agent code review with confidence-based filtering
simplicity-principles
Use when designing solutions, adding features, or refactoring by applying KISS, YAGNI, and Principle of Least Astonishment to write simple, predictable code.
solid-principles
Use during implementation when designing modules, functions, and components requiring SOLID principles for maintainable, flexible architecture.
structural-design-principles
Use when designing modules and components requiring Composition Over Inheritance, Law of Demeter, Tell Don't Ask, and Encapsulation principles that transcend programming paradigms.
test
Write tests for code using test-driven development principles
sre-incident-response
Use when responding to production incidents following SRE principles and best practices.
sre-monitoring-and-observability
Use when building comprehensive monitoring and observability systems.
Page 9 of 17 · 808 results