code-review
Code review a pull request
android-architecture
Use when implementing MVVM, clean architecture, dependency injection with Hilt, or structuring Android app layers.
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.
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.
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.
absinthe-schema
Use when designing GraphQL schemas with Absinthe. Covers type definitions, interfaces, unions, enums, and schema organization patterns.
go-concurrency
Use when Go concurrency with goroutines, channels, and sync patterns. Use when writing concurrent Go code.
python-async-patterns
Master Python asynchronous programming with asyncio, async/await,
bdd-principles
Core BDD concepts, philosophy, and the Three Amigos practice
prettier-configuration
Use when prettier configuration including options, config files, ignore patterns, and formatting rules.
prettier-integration
Use when prettier integration with editors, pre-commit hooks, ESLint, and CI/CD pipelines.
prettier-plugins
Use when prettier plugins including plugin ecosystem, custom parsers, and plugin development.
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
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.
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.
debug
Investigate and diagnose issues without necessarily fixing them
develop
>-
document
Generate or update documentation for code, APIs, or systems
explain
Explain code, concepts, or technical decisions in clear, understandable terms
explicit-configuration
Prefer explicit configuration over framework defaults to prevent environment-dependent failures
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.
professional-honesty
Use when responding to questions or providing information requiring professional honesty and directness over excessive agreeableness.
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
silent-execution
Reduce token waste by batching tool calls and avoiding narration between sequential operations
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
token-efficiency
Minimize token consumption through efficient tool usage patterns
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.
sre-reliability-engineering
Use when building reliable and scalable distributed systems.
angular-dependency-injection
Use when building modular Angular applications requiring dependency injection with providers, injectors, and services.
angular-rxjs-patterns
Use when handling async operations in Angular applications with observables, operators, and subjects.
angular-signals
Use when building Angular 16+ applications requiring fine-grained reactive state management and zone-less change detection.
django-cbv-patterns
Use when Django Class-Based Views for building modular, reusable views. Use when creating CRUD operations and complex view logic.
django-orm-patterns
Use when Django ORM patterns with models, queries, and relationships. Use when building database-driven Django applications.
django-rest-framework
Use when Django REST Framework for building APIs with serializers, viewsets, and authentication. Use when creating RESTful APIs.
Page 1 of 17 · 803 results