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
architecture-design
Use when designing system architecture, making high-level technical decisions, or planning major system changes. Focuses on structure, patterns, and long-term 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.
code-review
Code review a pull request
code-reviewer
Use during verification phase when conducting thorough code reviews and providing constructive feedback based on universal software quality principles.
debug
Investigate and diagnose issues without necessarily fixing them
debugging
Use when investigating bugs, diagnosing issues, or understanding unexpected behavior. Provides systematic approaches to finding root causes.
develop
Comprehensive 8-phase workflow for developing new features with quality enforcement
document
Generate or update documentation for code, APIs, or systems
documentation
Use when creating or updating documentation including READMEs, API docs, inline comments, or technical guides. Focuses on clarity and usefulness for the intended audience.
explain
Explain code, concepts, or technical decisions in clear, understandable terms
explainer
Use when explaining code, technical concepts, or implementation decisions. Provides structured approach to creating clear, understandable explanations tailored to the audience.
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.
performance-optimization
Use when optimizing code for performance, reducing bundle size, improving load times, or fixing performance bottlenecks. Emphasizes measurement-driven optimization.
plan
Create tactical implementation plan for a feature or task
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
refactoring
Use when restructuring code to improve quality without changing external behavior. Emphasizes safety through tests and incremental changes.
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.
technical-planning
Use when creating implementation plans for features or tasks. Focuses on tactical execution planning with clear tasks, dependencies, and success criteria.
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.
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.
ecto-changesets
Use when validating and casting data with Ecto changesets including field validation, constraints, nested changesets, and data transformation. Use for ensuring data integrity before database operations.
ecto-query-patterns
Use when querying data with Ecto.Query DSL including where clauses, joins, aggregates, preloading, and query composition. Use for building flexible database queries in Elixir applications.
ecto-schema-patterns
Use when defining data structures using Ecto schemas including fields, associations, embedded schemas, and schema metadata. Use for modeling domain data in Elixir applications.
ecto-schemas
Use when defining and working with Ecto schemas including field types, associations, and embedded schemas. Use when modeling database entities in Elixir.
effect-concurrency
Use when Effect concurrency patterns including fibers, fork, join, parallel execution, and race conditions. Use for concurrent operations in Effect applications.
effect-core-patterns
Use when Effect core patterns including Effect<A, E, R> type, succeed, fail, sync, promise, and Effect.gen for composing effects. Use for basic Effect operations.
effect-dependency-injection
Use when Effect dependency injection patterns including Context, Layer, service definitions, and dependency composition. Use for managing dependencies in Effect applications.
effect-error-handling
Use when Effect error handling patterns including catchAll, catchTag, either, option, and typed errors. Use for handling expected errors in Effect applications.
effect-resource-management
Use when Effect resource management patterns including Scope, addFinalizer, scoped effects, and automatic cleanup. Use for managing resources in Effect applications.
effect-schema
Use when @effect/schema patterns including schema definition, validation, parsing, encoding, and transformations. Use for type-safe data validation in Effect applications.
Page 1 of 16 · 768 results