thebushidocollective/han

android-jetpack-compose

Use when building Android UIs with Jetpack Compose, managing state with remember/mutableStateOf, or implementing declarative UI patterns.

fastapi-async-patterns

Use when FastAPI async patterns for building high-performance APIs. Use when handling concurrent requests and async operations.

storybook-story-writing

Use when creating or modifying Storybook stories for components. Ensures stories follow CSF3 format, properly showcase component variations, and build successfully.

atomic-design-fundamentals

Use when applying Atomic Design methodology to organize UI components into quarks, atoms, molecules, organisms, templates, and pages. Core principles and hierarchy.

angular-rxjs-patterns

Use when handling async operations in Angular applications with observables, operators, and subjects.

django-rest-framework

Use when Django REST Framework for building APIs with serializers, viewsets, and authentication. Use when creating RESTful APIs.

tailwind-responsive-design

Use when building responsive layouts and mobile-first designs with Tailwind CSS. Covers breakpoints, container queries, and responsive utilities.

android-architecture

Use when implementing MVVM, clean architecture, dependency injection with Hilt, or structuring Android app layers.

storybook-component-documentation

Use when creating or improving component documentation in Storybook. Helps generate comprehensive docs using MDX, autodocs, and JSDoc comments.

bdd-patterns

Use when applying Behavior-Driven Development patterns including Given-When-Then structure, feature files, and acceptance criteria. Use when writing BDD-style tests and specifications.

django-orm-patterns

Use when Django ORM patterns with models, queries, and relationships. Use when building database-driven Django applications.

solid-principles

Use during implementation when designing modules, functions, and components requiring SOLID principles for maintainable, flexible architecture.

atomic-design-integration

Use when integrating Atomic Design methodology with React, Vue, Angular, or other frameworks. Framework-specific implementation patterns.

storybook-play-functions

Use when adding interaction testing to Storybook stories. Enables automated testing of component behavior, user interactions, and state changes directly in stories.

elixir-ecto-patterns

Use when Elixir Ecto patterns including schemas, changesets, queries, and transactions. Use when building database-driven Elixir applications.

docker-compose-production

Use when deploying Docker Compose applications to production including security hardening, resource management, health checks, logging, monitoring, and high-availability patterns.

android-kotlin-coroutines

Use when implementing async operations with Kotlin coroutines, Flow, StateFlow, or managing concurrency in Android apps.

biome-linting

Use when applying Biome's linting capabilities, rule categories, and code quality enforcement to JavaScript/TypeScript projects.

elixir-otp-patterns

Use when Elixir OTP patterns including GenServer, Supervisor, Agent, and Task. Use when building concurrent, fault-tolerant Elixir applications.

monorepo-architecture

Use when designing monorepo structure, organizing packages, or migrating to monorepo architecture with architectural patterns for managing dependencies and scalable workspace configurations.

ansible-roles

Use when structuring and reusing code with Ansible roles for modular, maintainable automation and configuration management.

bdd-scenarios

Use when writing effective BDD scenarios including acceptance criteria, edge cases, and scenario organization. Use when defining behavior specifications.

cucumber-best-practices

Cucumber best practices, patterns, and anti-patterns

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.

cypress-advanced

Use when advanced Cypress features including custom commands, plugins, and network stubbing.

storybook-args-controls

Use when configuring interactive controls and args for Storybook stories. Helps create dynamic, explorable component demonstrations with proper type constraints.

rails-hotwire

Use when hotwire (Turbo and Stimulus) for building modern reactive Rails applications without complex JavaScript frameworks.

storybook-configuration

Use when setting up or configuring Storybook for a project. Covers main configuration, addons, builders, and framework-specific setup.

atomic-design-atoms

Use when creating atomic-level UI components like buttons, inputs, labels, and icons. The smallest building blocks of a design system.

nestjs-testing

Use when nestJS testing with unit tests, integration tests, and e2e tests. Use when building well-tested NestJS applications.

shell-best-practices

Use when writing shell scripts following modern best practices. Covers portable scripting, Bash patterns, error handling, and secure coding.

react-performance

Use when React performance optimization including memoization, lazy loading, and virtualization. Use when optimizing React applications.

ink-component-patterns

Use when building terminal UIs with Ink component patterns for React-based CLI applications.

ansible-playbooks

Use when writing and organizing Ansible playbooks for automated configuration management and infrastructure orchestration.

atomic-design-organisms

Use when building complex organisms from molecules and atoms like headers, footers, product cards, and sidebars. Organisms are distinct UI sections.

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.

bdd-principles

Core BDD concepts, philosophy, and the Three Amigos practice

nextjs-app-router

Use when next.js App Router with layouts, loading states, and streaming. Use when building modern Next.js 13+ applications.

nestjs-dependency-injection

Use when nestJS dependency injection with providers, modules, and decorators. Use when building modular NestJS applications.

playwright-page-object-model

Use when creating page objects or refactoring Playwright tests for better maintainability with Page Object Model patterns.

ios-uikit-architecture

Use when building iOS apps with UIKit, implementing MVVM/MVC/Coordinator patterns, or integrating UIKit with SwiftUI.

typescript-type-system

Use when working with TypeScript's type system including strict mode, advanced types, generics, type guards, and compiler configuration.

gluestack-components

Use when building UI with gluestack-ui components. Covers component composition, variants, sizes, states, accessibility props, and platform-specific considerations for React and React Native.

atomic-design-molecules

Use when composing atoms into molecule components like form fields, search bars, and card headers. Molecules are functional groups of atoms.

docker-compose-networking

Use when configuring networks and service communication in Docker Compose including bridge networks, overlay networks, service discovery, and inter-service communication.

atomic-design-templates

Use when creating page layouts without real content. Templates define the skeletal structure of pages using organisms, molecules, and atoms.

tailwind-utility-classes

Use when working with Tailwind CSS utility classes for layout, spacing, typography, colors, and visual effects. Covers utility-first CSS patterns and class composition.

markdownlint-custom-rules

Create custom linting rules for markdownlint including rule structure, parser integration, error reporting, and automatic fixing.

gluestack-theming

Use when customizing gluestack-ui themes and design tokens. Covers theme provider setup, design tokens, dark mode, NativeWind integration, and extending themes.

tailwind-performance

Use when optimizing Tailwind CSS for production, reducing bundle size, and improving performance. Covers PurgeCSS, JIT mode, and build optimization.

elixir-pattern-matching

Use when Elixir pattern matching including function clauses, case statements, with statements, and destructuring. Use for elegant control flow.

react-hooks-patterns

Use when React Hooks patterns including useState, useEffect, useContext, useMemo, useCallback, and custom hooks. Use for modern React development.

junit-fundamentals

Use when jUnit fundamentals including annotations, assertions, and test lifecycle for Java testing.

ios-swiftui-patterns

Use when building SwiftUI views, managing state with @State/@Binding/@ObservableObject, or implementing declarative UI patterns in iOS apps.

vitest-configuration

Use when vitest configuration, Vite integration, workspace setup, and test environment configuration for modern testing.

csharp-async-patterns

Use when C# async/await patterns including Task, ValueTask, async streams, and cancellation. Use when writing asynchronous C# code.

simplicity-principles

Use when designing solutions, adding features, or refactoring by applying KISS, YAGNI, and Principle of Least Astonishment to write simple, predictable code.

bdd-collaboration

Use when facilitating BDD collaboration between developers, testers, and business stakeholders. Use when running discovery workshops and example mapping sessions.

sip-protocol-fundamentals

Use when working with SIP messages, methods, call flows, and protocol fundamentals for VoIP applications.

react-native-web-performance

Use when optimizing React Native Web performance. Provides patterns for code splitting, bundle optimization, memoization, and web-specific performance improvements.

tailwind-components

Use when building reusable component patterns with Tailwind CSS. Covers component extraction, @apply directive, and composable design patterns.

eslint-custom

Use when custom ESLint rules and plugins including rule development, AST traversal, and publishing.

monorepo-workflows

Use when setting up CI/CD, implementing versioning, optimizing workflows, or managing releases with monorepo development workflows including version management, publishing, and team collaboration practices.

tailwind-configuration

Use when setting up or customizing Tailwind CSS configuration, theme customization, plugins, and build setup. Covers tailwind.config.js setup and content paths.

markdownlint-integration

Integrate markdownlint into development workflows including CLI usage, programmatic API, CI/CD pipelines, and editor integration.

angular-dependency-injection

Use when building modular Angular applications requiring dependency injection with providers, injectors, and services.

atomic-design-quarks

Use when working with design tokens, CSS custom properties, and primitive values that form the foundation below atoms. Quarks are the sub-atomic building blocks.

gluestack-accessibility

Use when ensuring accessible gluestack-ui implementations. Covers WAI-ARIA patterns, screen reader support, keyboard navigation, focus management, and WCAG 2.1 AA compliance.

sip-authentication-security

Use when implementing SIP authentication, security mechanisms, and encryption. Use when securing SIP servers, clients, or proxies.

cpp-modern-features

Use when working with modern C++ codebases requiring features from C++11 to C++23 including lambdas, move semantics, ranges, and concepts.

technical-planning

Use when creating implementation plans for features or tasks. Focuses on tactical execution planning with clear tasks, dependencies, and success criteria.

typescript-utility-types

Use when typeScript utility types, mapped types, and advanced type manipulation. Use when creating flexible, type-safe TypeScript code.

typescript-async-patterns

Use when typeScript async patterns including Promises, async/await, and async iterators with proper typing. Use when writing asynchronous TypeScript code.

relay-fragments-patterns

Use when relay fragment composition, data masking, colocation, and container patterns for React applications.

cpp-smart-pointers

Use when managing memory safely in C++ with smart pointers including unique_ptr, shared_ptr, weak_ptr, and RAII patterns.

rails-active-record-patterns

Use when active Record patterns including models, associations, queries, validations, and callbacks.

nextjs-data-fetching

Use when next.js data fetching patterns including SSG, SSR, and ISR. Use when building data-driven Next.js applications.

tensorflow-data-pipelines

Create efficient data pipelines with tf.data

orthogonality-principle

Use when designing modules, APIs, and system architecture requiring independent, non-overlapping components where changes in one don't affect others.

nestjs-guards-interceptors

Use when nestJS guards and interceptors for auth, logging, and transformation. Use when implementing cross-cutting concerns.

csharp-nullable-types

Use when C# nullable reference types, null safety patterns, and migration strategies. Use when ensuring null safety in C# code.

refactoring

Use when restructuring code to improve quality without changing external behavior. Emphasizes safety through tests and incremental changes.

tensorflow-neural-networks

Build and train neural networks with TensorFlow

relay-pagination

Use when relay pagination with cursor-based pagination, infinite scroll, load more patterns, and connection protocols.

eslint-rules

Use when eSLint built-in rules including rule configuration, severity levels, and disabling strategies.

cpp-templates-metaprogramming

Use when creating generic and type-safe C++ libraries with templates, SFINAE, concepts, and compile-time metaprogramming.

maven-dependency-management

Use when managing Maven dependencies, resolving dependency conflicts, configuring BOMs, or optimizing dependency trees in Java projects.

nextjs-server-components

Use when next.js Server Components for optimal performance. Use when building data-intensive Next.js applications.

monorepo-tooling

Use when setting up monorepo tooling, optimizing builds, or migrating between tools with Turborepo, Nx, Bazel, Lerna for efficient task running, caching, and code generation.

cucumber-step-definitions

Writing effective step definitions and organizing test code

phoenix-controllers

Handle HTTP requests with Phoenix controllers including actions, parameters, rendering, flash messages, and redirects

vue-composition-api

Use when Vue 3 Composition API with reactive refs, computed, and composables. Use when building modern Vue 3 applications.

kustomize-overlays

Use when managing environment-specific Kubernetes configurations with Kustomize overlays and patches.

zustand-advanced-patterns

Use when implementing advanced Zustand patterns including transient updates, subscriptions with selectors, store composition, and performance optimization techniques.

playwright-test-architecture

Use when setting up Playwright test projects and organizing test suites with proper configuration and project structure.

relay-mutations-patterns

Use when relay mutations with optimistic updates, connections, declarative mutations, and error handling.

prettier-integration

Use when prettier integration with editors, pre-commit hooks, ESLint, and CI/CD pipelines.

react-context-patterns

Use when React Context patterns for state management. Use when sharing state across component trees without prop drilling.

sre-reliability-engineering

Use when building reliable and scalable distributed systems.

ansible-inventory

Use when managing hosts and groups in Ansible inventory for organizing infrastructure and applying configurations across environments.

zustand-middleware

Use when implementing Zustand middleware for persistence, dev tools, immutability, and other enhanced store functionality. Covers persist, devtools, immer, and custom middleware.

kustomize-basics

Use when customizing Kubernetes configurations without templates using Kustomize overlays and patches.

csharp-linq

Use when lINQ query and method syntax, deferred execution, and performance optimization. Use when querying collections in C#.

vue-component-patterns

Use when Vue component patterns including props, emits, slots, and provide/inject. Use when building reusable Vue components.

vitest-performance

Use when vitest performance optimization including fast execution, watch mode, and parallelization strategies.

markdownlint-configuration

Configure markdownlint rules and options including rule management, configuration files, inline comments, and style inheritance.

ios-swift-concurrency

Use when implementing async/await, Task management, actors, or Combine reactive patterns in iOS applications.

markdown-syntax-fundamentals

Use when writing or editing markdown files. Covers headings, text formatting, lists, links, images, code blocks, and blockquotes.

playwright-fixtures-and-hooks

Use when managing test state and infrastructure with reusable Playwright fixtures and lifecycle hooks for efficient test setup and teardown.

markdown-documentation

Use when writing technical documentation, READMEs, or project documentation in markdown. Covers structure, conventions, and best practices.

zustand-typescript

Use when working with Zustand in TypeScript projects. Covers type-safe store creation, typed selectors, and advanced TypeScript patterns with Zustand.

angular-signals

Use when building Angular 16+ applications requiring fine-grained reactive state management and zone-less change detection.

cucumber-fundamentals

Core Cucumber concepts, Gherkin syntax, and feature file structure

vue-reactivity-system

Use when Vue reactivity system with refs, reactive, computed, and watchers. Use when managing complex state in Vue applications.

zustand-store-patterns

Use when creating and managing Zustand stores for React state management. Covers store creation, selectors, actions, and basic usage patterns.

phoenix-patterns

Use when applying Phoenix Framework best practices including context design, controller patterns, and application architecture. Use when building Phoenix applications.

prettier-configuration

Use when prettier configuration including options, config files, ignore patterns, and formatting rules.

playwright-bdd-gherkin-syntax

Use when writing Gherkin feature files, using Scenario Outline with Examples, applying tags for test organization, and leveraging Background sections for shared setup.

tensorflow-model-deployment

Deploy and serve TensorFlow models

sip-media-negotiation

Use when handling SDP offer/answer, codec negotiation, media capabilities, and RTP session setup in SIP applications.

sop-structure

Use when structuring Standard Operating Procedures with proper sections, organization, and markdown formatting. Covers SOP anatomy and section organization.

prettier-plugins

Use when prettier plugins including plugin ecosystem, custom parsers, and plugin development.

oop-polymorphism

Use when implementing polymorphism and interfaces in object-oriented design. Use when creating flexible, extensible systems with interchangeable components.

rspec-mocking

Use when rSpec mocking with doubles, stubs, mocks, spies, and partial mocking strategies.

ink-layout-styling

Use when creating terminal layouts with Ink using Flexbox-based positioning and styling for CLI applications.

pylint-configuration

Use when pylint configuration including pylintrc, message control, plugins, and scoring system.

react-native-web-navigation

Use when implementing navigation in React Native Web projects. Provides patterns for React Navigation, deep linking, and web-specific routing.

biome-configuration

Use when biome configuration including biome.json setup, schema versions, VCS integration, and project organization.

professional-honesty

Use when responding to questions or providing information requiring professional honesty and directness over excessive agreeableness.

shell-scripting-fundamentals

Use when writing or modifying Bash/shell scripts. Covers script structure, variables, quoting, conditionals, and loops with modern best practices.

kubernetes-security

Use when implementing Kubernetes security best practices including RBAC, pod security policies, and network policies.

fastapi-dependency-injection

Master FastAPI dependency injection for building modular, testable APIs.

go-error-handling

Use when Go error handling with error wrapping, sentinel errors, and custom error types. Use when handling errors in Go applications.

rspec-advanced

Use when advanced RSpec features including custom matchers, shared examples, metadata, and hooks.

scratch-workspace

Use when creating temporary files, drafts, experiments, or any content that should not be committed to version control. Ensures proper placement in .claude/.scratch with gitignore configuration.

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.

markdown-tables

Use when creating or formatting tables in markdown. Covers table syntax, alignment, escaping, and best practices.

test-driven-development

Use when writing new functions, adding features, fixing bugs, or refactoring by applying TDD principles - write failing tests before implementation code, make them pass, then refactor.

ink-hooks-state

Use when managing state and side effects in Ink applications using React hooks for terminal UIs.

jest-testing-patterns

Use when jest testing patterns including unit tests, mocks, spies, snapshots, and assertion techniques for comprehensive test coverage.

vitest-testing-patterns

Use when vitest testing patterns including unit tests, mocks, spies, and browser mode testing.

sre-monitoring-and-observability

Use when building comprehensive monitoring and observability systems.

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.

eslint-configuration

Use when eSLint configuration including config files, extends, plugins, and environment setup.

kustomize-generators

Use when generating ConfigMaps and Secrets with Kustomize for Kubernetes configuration management.

php security patterns

Use when essential PHP security patterns including input validation, SQL injection prevention, XSS protection, CSRF tokens, password hashing, secure session management, and defense-in-depth strategies for building secure PHP applications.

fastapi-validation

Use when FastAPI validation with Pydantic models. Use when building type-safe APIs with robust request/response validation.

react-native-web-testing

Use when testing React Native Web applications. Provides patterns for Jest, React Native Testing Library, component testing, and web-specific testing strategies.

mise-environment-management

Use when managing environment variables and project settings with Mise. Covers env configuration, direnv replacement, and per-directory settings.

gitlab-ci-pipeline-configuration

Use when configuring GitLab CI/CD pipelines, defining stages, or setting up workflow rules. Covers pipeline structure, stage ordering, and execution flow.

rust-error-handling

Use when Rust error handling with Result, Option, custom errors, thiserror, and anyhow. Use when handling errors in Rust applications.

react-native-web-core

Use when working with React Native Web projects. Provides core concepts, components, and cross-platform patterns for building web applications with React Native.

cypress-ci-cd

Use when cypress CI/CD integration including parallelization, test recording, and media capture.

rspec-fundamentals

Use when rSpec fundamentals including describe, context, it blocks, let, and basic matchers for BDD testing.

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.

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.

docker-compose-basics

Use when defining and running multi-container Docker applications with Docker Compose YAML configuration.

junit-parameterized

Use when jUnit parameterized tests with various value sources and test factories.

helm-templates

Use when working with Helm templates and template functions for generating Kubernetes manifests dynamically.

gluestack-mcp-tools

Use when discovering, exploring, or retrieving gluestack-ui components via MCP tools. Provides access to component source code, variants, demos, and metadata.

reactflow-fundamentals

Use when building node-based UIs, flow diagrams, workflow editors, or interactive graphs with React Flow. Covers setup, nodes, edges, controls, and interactivity.

oop-inheritance-composition

Use when deciding between inheritance and composition in object-oriented design. Use when creating class hierarchies or composing objects from smaller components.

git-storytelling-branch-strategy

Use when planning git branching strategies or managing branches for development. Helps create clear development narratives through effective branch organization and workflow patterns.

playwright-bdd-step-definitions

Use when creating step definitions with Given, When, Then, using createBdd() for step functions, implementing Page Object Model patterns, and sharing fixtures between steps.

effect-testing

Use when testing Effect code including Effect.gen in tests, test layers, mocking services, and testing error scenarios. Use for writing tests for Effect applications.

java-generics

Use when Java generics including type parameters, wildcards, and type bounds. Use when writing type-safe reusable code.

git-storytelling-commit-strategy

Use when planning commit strategies or determining when to commit changes. Helps developers commit early and often to tell the story of their development process.

sop-rfc2119

Use when writing SOPs that require precise requirement levels using RFC 2119 constraint keywords (MUST, SHOULD, MAY). Covers proper usage of requirement keywords for deterministic agent behavior.

react-native-web-styling

Use when styling React Native Web components. Provides patterns for StyleSheet API, platform-specific styles, responsive design, and theming.

jest-configuration

Use when jest configuration, setup files, module resolution, and project organization for optimal testing environments.

shell-error-handling

Use when implementing error handling, cleanup routines, or debugging in shell scripts. Covers traps, exit codes, and robust error patterns.

go-concurrency

Use when Go concurrency with goroutines, channels, and sync patterns. Use when writing concurrent Go code.

blueprints-maintenance

Use after modifying existing systems to update blueprint documentation. Read blueprints before changes, update after. Prevents documentation drift.

blueprints-organization

Use when managing blueprints directory structure and avoiding duplication. Always search existing blueprints before creating to prevent duplicate documentation. Handles naming conventions and cross-references.

gitlab-ci-best-practices

Use when optimizing GitLab CI/CD pipelines for performance, reliability, or maintainability. Covers pipeline optimization and organizational patterns.

sentry-alerts-issues

Use when configuring Sentry alerts, managing issues, or setting up notifications. Covers alert rules, issue triage, and integrations.

absinthe-resolvers

Use when implementing GraphQL resolvers with Absinthe. Covers resolver patterns, dataloader integration, batching, and error handling.

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.

claude-agent-sdk-agent-creation

Use when creating or configuring Claude AI agents using the Agent SDK. Covers agent initialization, configuration, and basic setup patterns.

oop-encapsulation

Use when applying encapsulation and information hiding principles in object-oriented design. Use when controlling access to object state and behavior.

mise-tool-management

Use when managing development tool versions with Mise. Covers installing tools, version pinning, and replacing language-specific version managers.

sop-maintenance

Use when updating, versioning, deprecating, or maintaining existing Standard Operating Procedures. Covers keeping SOPs accurate, relevant, and synchronized with implementation changes.

sop-authoring

Use when writing or creating new Standard Operating Procedures (SOPs) for AI agents. Covers effective SOP writing, clarity principles, and actionable instruction design.

explainer

Use when explaining code, technical concepts, or implementation decisions. Provides structured approach to creating clear, understandable explanations tailored to the audience.

testng-data-driven

Use when implementing data-driven tests with TestNG DataProviders, factory methods, and parameterization patterns.

jutsu-bun:bun-sqlite

Use when working with SQLite databases in Bun. Covers Bun's built-in SQLite driver, database operations, prepared statements, and transactions with high performance.

checkstyle-custom

Use when developing custom Checkstyle checks, filters, and plugin integrations for project-specific Java code standards.

testng-fundamentals

Use when working with TestNG annotations, assertions, test lifecycle, and configuration for Java testing.

testng-parallel

Use when configuring parallel test execution with TestNG including thread pools, suite configuration, and synchronization.

apollo-caching-strategies

Use when implementing Apollo caching strategies including cache policies, optimistic UI, cache updates, and normalization.

c-data-structures

Use when implementing data structures in C including arrays, linked lists, trees, and hash tables with manual memory management.

apollo-server-patterns

Use when building GraphQL APIs with Apollo Server requiring resolvers, data sources, schema design, and federation.

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.

shell-portability

Use when writing shell scripts that need to run across different systems, shells, or environments. Covers POSIX compatibility and platform differences.

act-local-testing

Use when testing GitHub Actions workflows locally with act. Covers act CLI usage, Docker configuration, debugging workflows, and troubleshooting common issues when running workflows on your local machine.

java-streams-api

Use when Java Streams API for functional-style data processing. Use when processing collections with streams.

playwright-bdd-configuration

Use when configuring Playwright BDD projects, setting up defineBddConfig(), configuring feature and step file paths, and integrating with Playwright config.

kubernetes-resources

Use when managing Kubernetes resources including deployments, services, configmaps, and secrets.

performance-optimization

Use when optimizing code for performance, reducing bundle size, improving load times, or fixing performance bottlenecks. Emphasizes measurement-driven optimization.

python-type-system

Use when Python's type system including type hints, mypy, Protocol, TypedDict, and Generics. Use when working with Python type annotations.

effect-dependency-injection

Use when Effect dependency injection patterns including Context, Layer, service definitions, and dependency composition. Use for managing dependencies in Effect applications.

rails-action-controller-patterns

Use when action Controller patterns including routing, filters, strong parameters, and REST conventions.

blueprints-writing

Use when creating or updating technical blueprint documentation for new features, API changes, or architectural modifications. Always search existing blueprints first to avoid duplication, then write with proper structure.

claude-agent-sdk-tool-integration

Use when integrating tools, permissions, and MCP servers with Claude AI agents using the Agent SDK.

pylint-integration

Use when pylint CI integration including plugins, editor integration, and performance tuning.

phoenix-views-templates

Render views and templates in Phoenix using HEEx templates, function components, slots, and assigns

nim metaprogramming

Use when nim's metaprogramming including macros, templates, compile-time evaluation, AST manipulation, code generation, DSL creation, and leveraging compile-time computation for performance and abstraction in systems programming.

biome-formatting

Use when formatting JavaScript/TypeScript code with Biome's fast formatter including patterns, options, and code style management.

absinthe-subscriptions

Use when implementing real-time GraphQL subscriptions with Absinthe. Covers Phoenix channels, PubSub, and subscription patterns.

kotlin coroutines

Use when kotlin coroutines for structured concurrency including suspend functions, coroutine builders, Flow, channels, and patterns for building efficient asynchronous code with cancellation and exception handling.

swift protocol-oriented programming

Use when protocol-oriented programming in Swift including protocol extensions, default implementations, protocol composition, associated types, and designing flexible, reusable abstractions that favor composition over inheritance.

cypress-fundamentals

Use when cypress fundamentals including commands, assertions, fixtures, and E2E testing patterns.

mise-task-configuration

Use when defining and configuring Mise tasks in mise.toml. Covers task definitions, dependencies, file tasks, and parallel execution.

mocha-assertions

Use when assertion libraries for Mocha including Chai with expect, should, and assert styles.

sre-incident-response

Use when responding to production incidents following SRE principles and best practices.

pylint-checkers

Use when pylint checkers including built-in checkers, custom checkers, and checker development.

rust-ownership-system

Use when Rust's ownership system including ownership rules, borrowing, lifetimes, and memory safety. Use when working with Rust memory management.

fnox-security-best-practices

Use when implementing secure secrets management with Fnox. Covers encryption, key management, access control, and security hardening.

sentry-sdk-configuration

Use when initializing Sentry in applications, configuring SDK options, or setting up integrations across different frameworks and platforms.

absinthe-schema

Use when designing GraphQL schemas with Absinthe. Covers type definitions, interfaces, unions, enums, and schema organization patterns.

jest-advanced

Use when advanced Jest features including custom matchers, parameterized tests with test.each, coverage configuration, and performance optimization.

effect-schema

Use when @effect/schema patterns including schema definition, validation, parsing, encoding, and transformations. Use for type-safe data validation in Effect applications.

reactflow-custom-nodes

Use when creating custom React Flow nodes, edges, and handles. Covers custom node components, resizable nodes, toolbars, and advanced customization.

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.

claude-agent-sdk-context-management

Use when managing agent context, memory, and conversation state in Claude AI agents using the Agent SDK.

python-async-patterns

Master Python asynchronous programming with asyncio, async/await,

pulumi-basics

Use when writing infrastructure-as-code with Pulumi using programming languages for cloud resource provisioning.

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.

sentry-release-management

Use when managing Sentry releases, uploading source maps, or tracking deployments. Covers release health and commit association.

sentry-error-capturing

Use when capturing and reporting errors to Sentry, adding context, or handling exceptions. Covers error boundaries, context enrichment, and fingerprinting.

mocha-fundamentals

Use when mocha test structure, hooks, and async testing patterns for JavaScript testing.

graphql-performance

Use when optimizing GraphQL API performance with query complexity analysis, batching, caching strategies, depth limiting, monitoring, and database optimization.

cocoapods-publishing-workflow

Use when publishing CocoaPods libraries to CocoaPods Trunk. Covers pod trunk registration, podspec validation, version management, and publishing best practices for successful library distribution.

pulumi-components

Use when building reusable infrastructure components with Pulumi for modular, composable cloud resources.

ruby-metaprogramming

Use when working with Ruby metaprogramming features including dynamic method definition, method_missing, class_eval, define_method, and reflection.

cocoapods-podspec-fundamentals

Use when creating or modifying CocoaPods podspec files. Covers required attributes, file patterns, dependencies, and platform specifications for iOS, macOS, tvOS, watchOS, and visionOS projects.

graphql-inspector-audit

Use when auditing GraphQL operations for complexity metrics, depth analysis, directive usage, or query performance concerns.

c-memory-management

Use when managing memory in C programs with malloc/free, pointers, and avoiding common memory safety pitfalls.

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.

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.

terraform-modules

Use when creating and using reusable Terraform modules for organizing and sharing infrastructure code.

c-systems-programming

Use when writing low-level system software in C requiring file I/O, process management, signals, and system calls.

rubocop-integration

Use when ruboCop CI integration including GitHub Actions, plugins, and performance optimization.

swift concurrency

Use when swift's modern concurrency model including async/await, actors, task groups, structured concurrency, and async sequences for building safe, performant concurrent code without data races or callback pyramids.

checkstyle-rules

Use when applying Checkstyle built-in checks for Java code including naming conventions, code metrics, and suppressions.

crystal-concurrency

Use when implementing concurrent programming in Crystal using fibers, channels, and parallel execution patterns for high-performance, non-blocking applications.

helm-charts

Use when understanding and creating Helm charts for packaging and deploying Kubernetes applications.

crystal-engineer

Use when working with Crystal language development including WebSocket communication, TLS/SSL configuration, HTTP frameworks, ORM operations, and high-performance concurrent systems.

shfmt-formatting

Use when formatting shell scripts with shfmt. Covers consistent formatting patterns, shell dialect support, common issues, and editor integration.

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.

gitlab-ci-job-configuration

Use when defining GitLab CI jobs, configuring scripts, setting up environments, or managing job dependencies. Covers job structure and execution options.

rubocop-cops

Use when ruboCop cops including built-in cops, configuration, auto-correction, and development.

go-interfaces

Use when Go interfaces including interface design, duck typing, and composition patterns. Use when designing Go APIs and abstractions.

sentry-performance-monitoring

Use when setting up performance monitoring, distributed tracing, or profiling with Sentry. Covers transactions, spans, and performance insights.

maven-build-lifecycle

Use when working with Maven build phases, goals, profiles, or customizing the build process for Java projects.

graphql-schema-design

Use when designing GraphQL schemas with type system, SDL patterns, field design, pagination, directives, and versioning strategies for maintainable and scalable APIs.

act-workflow-syntax

Use when creating or modifying GitHub Actions workflow files. Provides guidance on workflow syntax, triggers, jobs, steps, and expressions for creating valid GitHub Actions workflows that can be tested locally with act.

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.

nim memory management

Use when nim's memory management including garbage collection strategies, manual memory control, destructors, move semantics, ref/ptr types, memory safety, and optimization techniques for performance-critical systems programming.

erlang otp behaviors

Use when oTP behaviors including gen_server for stateful processes, gen_statem for state machines, supervisors for fault tolerance, gen_event for event handling, and building robust, production-ready Erlang applications with proven patterns.

clippy-configuration

Use when configuring Clippy for Rust projects with TOML config, lint groups, attributes, and workspace setup.

clippy-custom

Use when developing custom Clippy lints, implementing lint passes, and contributing to Clippy for Rust code standards.

mocha-configuration

Use when mocha configuration including reporters, config files, plugins, and CI integration.

objective-c protocols and categories

Use when objective-C protocols for defining interfaces and categories for extending classes, including formal protocols, optional methods, class extensions, and patterns for modular, reusable code design.

checkstyle-configuration

Use when configuring Checkstyle for Java projects with XML config, custom checks, properties, and module setup.

apollo-client-patterns

Use when implementing Apollo Client patterns for queries, mutations, cache management, and local state in React applications.

pytest-fixtures

Use when pytest fixtures, conftest files, parametrize decorators, and fixture scopes for comprehensive test setup.

act-docker-setup

Use when configuring Docker environments for act, selecting runner images, managing container resources, or troubleshooting Docker-related issues with local GitHub Actions testing.

gitlab-ci-variables-secrets

Use when configuring GitLab CI/CD variables, managing secrets, or integrating with external secret providers. Covers secure credential handling.

cocoapods-subspecs-organization

Use when organizing complex CocoaPods libraries into subspecs. Covers modular architecture, dependency management between subspecs, and default subspecs patterns for better code organization and optional features.

pytest-plugins

Use when pytest plugin ecosystem including pytest-cov, pytest-mock, and custom plugin development.

gitlab-ci-artifacts-caching

Use when configuring artifacts for inter-job data passing or caching for faster builds. Covers cache strategies and artifact management.

python-data-classes

Use when Python data modeling with dataclasses, attrs, and Pydantic. Use when creating data structures and models.

ameba-custom-rules

Use when creating custom Ameba rules for Crystal code analysis including rule development, AST traversal, issue reporting, and rule testing.

pulumi-stacks

Use when managing multiple environments with Pulumi stacks for development, staging, and production deployments.

graphql-inspector-validate

Use when validating GraphQL operations/documents against a schema, checking query depth, complexity, or fragment usage.

graphql-resolvers

Use when implementing GraphQL resolvers with resolver functions, context management, DataLoader batching, error handling, authentication, and testing strategies.

cocoapods-test-specs

Use when adding automated tests to CocoaPods libraries using test specs. Covers test spec configuration, app host requirements, and testing patterns that integrate with pod lib lint validation.

rubocop-configuration

Use when ruboCop configuration including YAML config, departments, inheritance, and customization.

fnox-configuration

Use when configuring Fnox secrets management with fnox.toml. Covers file structure, secrets definition, profiles, and hierarchical configurations.

objective-c arc patterns

Use when automatic Reference Counting in Objective-C including strong/weak references, retain cycles, ownership qualifiers, bridging with Core Foundation, and patterns for memory-safe code without manual retain/release.

runbooks-troubleshooting-guides

Use when creating troubleshooting guides and diagnostic procedures for operational issues. Covers problem diagnosis, root cause analysis, and systematic debugging.

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.

helm-values

Use when managing Helm values files and configuration overrides for customizing Kubernetes deployments.

erlang distribution

Use when erlang distributed systems including node connectivity, distributed processes, global name registration, distributed supervision, network partitions, and building fault-tolerant multi-node applications on the BEAM VM.

ruby-gems-bundler

Use when working with Ruby gems, Bundler for dependency management, creating gemspecs, and publishing gems to RubyGems.

java-concurrency

Use when Java concurrency with ExecutorService, CompletableFuture, and virtual threads. Use when building concurrent applications.

shfmt-configuration

Use when configuring shfmt for shell script formatting including .shfmt.toml setup, EditorConfig integration, and project-specific settings.

ruby-standard-library

Use when working with Ruby's standard library including Enumerable, File I/O, Time/Date, Regular Expressions, and core classes.

nim c interop

Use when nim-C interoperability including calling C from Nim, wrapping C libraries, importc/exportc pragmas, header generation, FFI patterns, and building high-performance systems code integrating Nim with existing C codebases.

django-cbv-patterns

Use when Django Class-Based Views for building modular, reusable views. Use when creating CRUD operations and complex view logic.

cocoapods-privacy-manifests

Use when implementing iOS 17+ privacy manifests for CocoaPods libraries. Covers PrivacyInfo.xcprivacy file creation, required reasons API declarations, and proper resource bundle integration for App Store compliance.

effect-concurrency

Use when Effect concurrency patterns including fibers, fork, join, parallel execution, and race conditions. Use for concurrent operations in Effect applications.

swift optionals patterns

Use when swift's optional handling patterns including optional binding, chaining, nil coalescing, and modern approaches to safely working with optional values while avoiding common pitfalls and force unwrapping.

erlang concurrency

Use when erlang's concurrency model including lightweight processes, message passing, process links and monitors, error handling patterns, selective receive, and building massively concurrent systems on the BEAM VM.

graphql-inspector-ci

Use when setting up GraphQL Inspector in CI/CD pipelines, GitHub Actions, or GitLab CI for automated schema validation.

objective-c blocks and gcd

Use when blocks (closures) and Grand Central Dispatch in Objective-C for concurrent programming including block syntax, capture semantics, dispatch queues, dispatch groups, and patterns for thread-safe asynchronous code.

debugging

Use when investigating bugs, diagnosing issues, or understanding unexpected behavior. Provides systematic approaches to finding root causes.

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.

gleam actor model

Use when oTP actor patterns in Gleam including processes, message passing, GenServer implementations, supervisors, fault tolerance, state management, and building concurrent, fault-tolerant applications on the Erlang VM.

crystal-macros

Use when implementing compile-time metaprogramming in Crystal using macros for code generation, DSLs, compile-time computation, and abstract syntax tree manipulation.

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.

dialyzer-integration

Use when integrating Dialyzer into development workflows and CI/CD pipelines for Erlang/Elixir projects.

ruby-blocks-procs-lambdas

Use when working with Ruby blocks, procs, lambdas, and functional programming patterns including closures and higher-order functions.

fnox-providers

Use when configuring Fnox providers for encryption and secret storage. Covers age encryption, cloud providers (AWS, Azure, GCP), and password managers.

effect-resource-management

Use when Effect resource management patterns including Scope, addFinalizer, scoped effects, and automatic cleanup. Use for managing resources in Effect applications.

runbooks-incident-response

Use when creating incident response procedures and on-call playbooks. Covers incident management, communication protocols, and post-mortem documentation.

clippy-lints

Use when applying Clippy lint categories for Rust code including correctness, performance, style, and custom lint configuration.

phoenix-routing

Define routes and URL helpers in Phoenix applications including resources, scopes, pipelines, and verified routes

syncpack-configuration

Use when setting up or configuring syncpack for a monorepo. Covers configuration files, workspace detection, and custom rule definitions for dependency version management.

syncpack-version-groups

Use when defining version policies, banning dependencies, pinning versions, or creating partitioned version groups in syncpack. Covers advanced version management patterns.

jutsu-expo:expo-router

Use when implementing file-based routing in Expo with Expo Router. Covers app directory structure, navigation, layouts, dynamic routes, and deep linking.

rust-async-patterns

Use when Rust async programming with tokio, async/await, and futures. Use when writing asynchronous Rust code.

graphql-inspector-diff

Use when detecting breaking changes between GraphQL schema versions, comparing schemas across branches, or validating schema migrations.

ecto-schemas

Use when defining and working with Ecto schemas including field types, associations, and embedded schemas. Use when modeling database entities in Elixir.

php composer and autoloading

Use when composer package management and PSR-4 autoloading including dependency management, autoload strategies, package creation, version constraints, and patterns for modern PHP project organization and distribution.

kubernetes-manifests

Use when writing and deploying Kubernetes manifests for container orchestration.

ameba-integration

Use when integrating Ameba into development workflows including CI/CD pipelines, pre-commit hooks, GitHub Actions, and automated code review processes.

junit-extensions

Use when jUnit extensions including custom extensions, rules, and conditional test execution.

credo-custom-checks

Use when creating custom Credo checks for project-specific code quality rules and standards in Elixir.

runbooks-structure

Use when creating structured operational runbooks for human operators. Covers runbook organization, documentation patterns, and best practices for clear operational procedures.

credo-checks

Use when understanding and fixing common Credo check issues for Elixir code quality and consistency.

dialyzer-configuration

Use when configuring Dialyzer for Erlang/Elixir type checking and static analysis.

ruby-oop

Use when working with Ruby's object-oriented programming features including classes, modules, inheritance, mixins, and method visibility.

terraform-state

Use when managing Terraform state files, remote backends, and state locking for infrastructure coordination.

architect

Design system architecture and high-level technical strategy

credo-configuration

Use when configuring Credo static analysis for Elixir projects requiring customized code quality rules and settings.

jutsu-react-native:react-native-navigation

Use when implementing navigation in React Native apps with React Navigation. Covers stack, tab, drawer navigation, deep linking, and navigation patterns.

code-reviewer

Use during verification phase when conducting thorough code reviews and providing constructive feedback based on universal software quality principles.

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.

dialyzer-analysis

Use when analyzing and fixing Dialyzer warnings and type discrepancies in Erlang/Elixir code.

bun-sqlite

Use when working with SQLite databases in Bun. Covers Bun's built-in SQLite driver, database operations, prepared statements, and transactions with high performance.

pytest-advanced

Use when advanced Pytest features including markers, custom assertions, hooks, and coverage configuration.

maven-plugin-configuration

Use when configuring Maven plugins, setting up common plugins like compiler, surefire, jar, or creating custom plugin executions.

ameba-configuration

Use when configuring Ameba rules and settings for Crystal projects including .ameba.yml setup, rule management, severity levels, and code quality enforcement.

explain

Explain code, concepts, or technical decisions in clear, understandable terms

terraform-configuration

Use when writing and organizing Terraform infrastructure-as-code configurations for cloud resource provisioning.

jutsu-bun:bun-bundler

Use when bundling JavaScript/TypeScript code with Bun's fast bundler. Covers building for different targets, tree-shaking, code splitting, and optimization strategies.

jutsu-bun:bun-package-manager

Use when managing dependencies with Bun's package manager. Covers installing packages, workspaces, lockfiles, and migrating from npm/yarn/pnpm to Bun.

jutsu-bun:bun-testing

Use when writing tests with Bun's built-in test runner. Covers test organization, assertions, mocking, and snapshot testing using Bun's fast test infrastructure.

jutsu-bun:bun-runtime

Use when working with Bun's runtime APIs including file I/O, HTTP servers, and native APIs. Covers modern JavaScript/TypeScript execution in Bun's fast runtime environment.

jutsu-react-native:react-native-performance

Use when optimizing React Native app performance. Covers FlatList optimization, memoization, image optimization, bundle size reduction, and profiling techniques.

jutsu-expo:expo-updates

Use when implementing over-the-air (OTA) updates with Expo Updates. Covers update configuration, checking for updates, and update strategies.

plan

Create tactical implementation plan for a feature or task

expo-modules

Use when working with Expo SDK modules for camera, location, notifications, file system, and other device APIs. Covers permissions, configurations, and best practices.

jutsu-react-native:react-native-native-modules

Use when building or integrating native modules in React Native. Covers creating native modules, Turbo Modules, bridging native code, and accessing platform-specific APIs.

figma-sync-design-system

Sync design system components between Figma and code using Code Connect mappings

jutsu-expo:expo-build

Use when building and deploying Expo apps with EAS Build. Covers build configuration, development builds, production builds, and app store submission.

create-blueprint

Research a specific system and create or update its blueprints/ documentation

search-code

Search for code across GitHub repositories

jutsu-react-native:react-native-platform

Use when handling platform-specific code in React Native for iOS and Android. Covers Platform API, platform-specific components, native modules, and cross-platform best practices.

fix

Debug and fix bugs, errors, or unexpected behavior

bun-package-manager

Use when managing dependencies with Bun's package manager. Covers installing packages, workspaces, lockfiles, and migrating from npm/yarn/pnpm to Bun.

jutsu-react-native:react-native-styling

Use when styling React Native components with StyleSheet, Flexbox layout, responsive design, and theming. Covers platform-specific styling and design systems.

jutsu-expo:expo-modules

Use when working with Expo SDK modules for camera, location, notifications, file system, and other device APIs. Covers permissions, configurations, and best practices.

debug

Investigate and diagnose issues without necessarily fixing them

create-pr

Create a new pull request in a GitHub repository

comment

Add a comment to a ClickUp task

jutsu-react-native:react-native-components

Use when building React Native UI components with core components, custom components, and component patterns. Covers View, Text, Image, ScrollView, FlatList, and component composition.

refactor

Restructure code to improve quality without changing behavior

review

Multi-agent code review with confidence-based filtering

develop

Comprehensive 8-phase workflow for developing new features with quality enforcement

jutsu-expo:expo-config

Use when configuring Expo apps with app.json, app.config.js, and EAS configuration. Covers app metadata, plugins, build configuration, and environment variables.

document

Generate or update documentation for code, APIs, or systems

figma-extract-tokens

Extract design tokens and variables from a Figma file to create or update a design system

optimize

Optimize code for performance, readability, or efficiency

php modern features

code-review

Code review a pull request

figma-analyze-frame

Analyze a Figma frame's structure, properties, and implementation considerations

analyze-performance

Analyze performance metrics and identify slow transactions in Sentry

expo-config

Use when configuring Expo apps with app.json, app.config.js, and EAS configuration. Covers app metadata, plugins, build configuration, and environment variables.

expo-router

Use when implementing file-based routing in Expo with Expo Router. Covers app directory structure, navigation, layouts, dynamic routes, and deep linking.

kotlin null safety

generate-blueprints

Deeply research all systems and create or update blueprints/ documentation for the entire codebase

scala type system

lua tables patterns

figma-generate-component

Generate production-ready code from a Figma component or frame using the Figma MCP server

lua c integration

scala functional patterns

gleam erlang interop

scala collections

lua coroutines

gleam type system

review-pr

Get comprehensive review of a GitHub pull request