TheBushidoCollective

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

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

Master Python asynchronous programming with asyncio, async/await, and concurrent.futures. Use for async code and concurrency patterns.

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

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

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

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

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

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

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

Use when testing GitHub Actions workflows locally with act. Covers act CLI usage, Docker configuration, debugging workflows, and troubleshooting commo...

Use when creating or modifying GitHub Actions workflow files. Provides guidance on workflow syntax, triggers, jobs, steps, and expressions for creatin...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Use when designing system architecture, making high-level technical decisions, or planning major system changes. Focuses on structure, patterns, and l...

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

Use when multiple fix attempts fail and you need to systematically restore to a working baseline and reimplement instead of fixing broken code.

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

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

Core BDD concepts, philosophy, and the Three Amigos practice

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

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

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

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

Use after modifying existing systems to update blueprint documentation. Read blueprints with read_blueprint before changes, update with write_blueprin...

Use when managing blueprints directory structure and avoiding duplication. Always search_blueprints before creating to prevent duplicate documentation...

Use when creating or updating technical blueprint documentation for new features, API changes, or architectural modifications. Always use search_bluep...

Use when modifying existing files, refactoring, improving code quality, or touching legacy code by applying the Boy Scout Rule to leave code better th...

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

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

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 fas...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Use when implementing iOS 17+ privacy manifests for CocoaPods libraries. Covers PrivacyInfo.xcprivacy file creation, required reasons API declarations...

Use when publishing CocoaPods libraries to CocoaPods Trunk. Covers pod trunk registration, podspec validation, version management, and publishing best...

Use when organizing complex CocoaPods libraries into subspecs. Covers modular architecture, dependency management between subspecs, and default subspe...

Use when adding automated tests to CocoaPods libraries using test specs. Covers test spec configuration, app host requirements, and testing patterns t...

Use when annotating code with structured metadata, tags, and markers for AI-assisted development workflows. Covers annotation formats, semantic tags, ...

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

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

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

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

Use when modern C++ features from C++11/14/17/20 including auto, lambdas, range-based loops, structured bindings, and concepts.

Use when C++ smart pointers including unique_ptr, shared_ptr, and weak_ptr for automatic memory management following RAII principles.

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

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

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

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

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

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

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

Use when C# asynchronous programming with async/await, Task, ValueTask, ConfigureAwait, and async streams for responsive applications.

Use when lINQ (Language Integrated Query) with query and method syntax, deferred execution, expression trees, and performance optimization.

Use when C# nullable reference types and value types for null safety, nullable annotations, and patterns for handling null values.

Cucumber best practices, patterns, and anti-patterns

Core Cucumber concepts, Gherkin syntax, and feature file structure

Writing effective step definitions and organizing test code

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

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

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

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

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

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

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

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

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

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

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

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

Use when deploying Docker Compose applications to production including security hardening, resource management, health checks, logging, monitoring, an...

Use when creating or updating documentation including READMEs, API docs, inline comments, or technical guides. Focuses on clarity and usefulness for t...

Use when creating bidirectional links between code and documentation. Covers link patterns, documentation references, context preservation across arti...

Use when validating and casting data with Ecto changesets including field validation, constraints, nested changesets, and data transformation. Use for...

Use when querying data with Ecto.Query DSL including where clauses, joins, aggregates, preloading, and query composition. Use for building flexible da...

Use when defining data structures using Ecto schemas including fields, associations, embedded schemas, and schema metadata. Use for modeling domain da...

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

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

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...

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

Use when Effect error handling patterns including catchAll, catchTag, either, option, and typed errors. Use for handling expected errors in Effect app...

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

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

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

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

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

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

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

Use when erlang's concurrency model including lightweight processes, message passing, process links and monitors, error handling patterns, selective r...

Use when erlang distributed systems including node connectivity, distributed processes, global name registration, distributed supervision, network par...

Use when oTP behaviors including gen_server for stateful processes, gen_statem for state machines, supervisors for fault tolerance, gen_event for even...

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

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

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

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

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

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

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

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

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

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

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

Master FastAPI dependency injection for building modular, testable APIs. Use when creating reusable dependencies and services.

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

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

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

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

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

Use when writing commit messages that clearly communicate changes and tell the story of development. Helps create informative, well-structured commit ...

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

Use when writing commit messages that clearly communicate changes and tell the story of development. Helps create informative, well-structured commit ...

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

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

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

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

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

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

Use when oTP actor patterns in Gleam including processes, message passing, GenServer implementations, supervisors, fault tolerance, state management, ...

Use when gleam-Erlang interoperability including calling Erlang code from Gleam, using Erlang libraries, external functions, working with Erlang types...

Use when gleam-Erlang interoperability including calling Erlang code from Gleam, using Erlang libraries, external functions, working with Erlang types...

Use when gleam's type system including algebraic data types, custom types, pattern matching, generic types, type inference, opaque types, exhaustive c...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 fas...

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

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

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

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

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

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

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

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

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

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

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

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

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

Use when kotlin coroutines for structured concurrency including suspend functions, coroutine builders, Flow, channels, and patterns for building effic...

Use when domain-specific language design in Kotlin using type-safe builders, infix functions, operator overloading, lambdas with receivers, and patter...

Use when kotlin's null safety system including nullable types, safe calls, Elvis operator, smart casts, and patterns for eliminating NullPointerExcept...

Use when writing and deploying Kubernetes manifests for container orchestration.

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

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

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

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

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

Use when modifying, removing, or refactoring code that lacks test coverage. Emphasizes the danger of untested changes and the RGR workflow to add char...

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...

Use when lua coroutines for cooperative multitasking including coroutine creation, yielding and resuming, passing values, generators, iterators, async...

Use when lua tables as the universal data structure including arrays, dictionaries, objects, metatables, object-oriented patterns, data structures, an...

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

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

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

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

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

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

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

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

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

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

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

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

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

Use when designing monorepo structure, organizing packages, or migrating to monorepo architecture with architectural patterns for managing dependencie...

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

Use when setting up CI/CD, implementing versioning, optimizing workflows, or managing releases with monorepo development workflows including version m...

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

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

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

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

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

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

Use when nim-C interoperability including calling C from Nim, wrapping C libraries, importc/exportc pragmas, header generation, FFI patterns, and buil...

Use when nim's memory management including garbage collection strategies, manual memory control, destructors, move semantics, ref/ptr types, memory sa...

Use when nim's metaprogramming including macros, templates, compile-time evaluation, AST manipulation, code generation, DSL creation, and leveraging c...

Use when leaving structured notes, comments, and annotations in code. Covers AI note-taking patterns, TODO formats, context preservation, and developm...

Use when leaving structured notes, comments, and annotations in code. Covers AI note-taking patterns, TODO formats, context preservation, and developm...

Use when automatic Reference Counting in Objective-C including strong/weak references, retain cycles, ownership qualifiers, bridging with Core Foundat...

Use when blocks (closures) and Grand Central Dispatch in Objective-C for concurrent programming including block syntax, capture semantics, dispatch qu...

Use when objective-C protocols for defining interfaces and categories for extending classes, including formal protocols, optional methods, class exten...

Use when automatic Reference Counting in Objective-C including strong/weak references, retain cycles, ownership qualifiers, bridging with Core Foundat...

Use when blocks (closures) and Grand Central Dispatch in Objective-C for concurrent programming including block syntax, capture semantics, dispatch qu...

Use when objective-C protocols for defining interfaces and categories for extending classes, including formal protocols, optional methods, class exten...

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

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

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

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

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

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

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

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

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

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

Use when composer package management and PSR-4 autoloading including dependency management, autoload strategies, package creation, version constraints...

Use when composer package management and PSR-4 autoloading including dependency management, autoload strategies, package creation, version constraints...

Use when modern PHP features including typed properties, union types, match expressions, named arguments, attributes, enums, and patterns for writing ...

Use when essential PHP security patterns including input validation, SQL injection prevention, XSS protection, CSRF tokens, password hashing, secure s...

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

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

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

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

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

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

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

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

Use when implementing iOS 17+ privacy manifests for CocoaPods libraries. Covers PrivacyInfo.xcprivacy file creation, required reasons API declarations...

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

Use when setting up or organizing Claude Code project memory (CLAUDE.md, .claude/rules/) for better context awareness, consistent behavior, and projec...

Use automatically during development workflows when making claims about tests, builds, verification, or code quality requiring concrete evidence to en...

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

Use when publishing CocoaPods libraries to CocoaPods Trunk. Covers pod trunk registration, podspec validation, version management, and publishing best...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Use when scala collections including immutable/mutable variants, List, Vector, Set, Map operations, collection transformations, lazy evaluation with v...

Use when functional programming patterns in Scala including higher-order functions, immutability, pattern matching, algebraic data types, monads, for-...

Use when scala's advanced type system including generics, variance, type bounds, implicit conversions, type classes, higher-kinded types, path-depende...

Use when creating temporary files, drafts, experiments, or any content that should not be committed to version control. Ensures proper placement in .c...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Use when updating, versioning, deprecating, or maintaining existing Standard Operating Procedures. Covers keeping SOPs accurate, relevant, and synchro...

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

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

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

Use when building comprehensive monitoring and observability systems.

Use when building comprehensive monitoring and observability systems.

Use when building reliable and scalable distributed systems.

Use when building reliable and scalable distributed systems.

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

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

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

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

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

Use when designing modules and components requiring Composition Over Inheritance, Law of Demeter, Tell Don't Ask, and Encapsulation principles that tr...

Use when organizing complex CocoaPods libraries into subspecs. Covers modular architecture, dependency management between subspecs, and default subspe...

Use when swift's modern concurrency model including async/await, actors, task groups, structured concurrency, and async sequences for building safe, p...

Use when swift's optional handling patterns including optional binding, chaining, nil coalescing, and modern approaches to safely working with optiona...

Use when protocol-oriented programming in Swift including protocol extensions, default implementations, protocol composition, associated types, and de...

Use when protocol-oriented programming in Swift including protocol extensions, default implementations, protocol composition, associated types, and de...

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

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

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

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

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

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

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

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

Create efficient data pipelines with tf.data

Deploy and serve TensorFlow models

Build and train neural networks with TensorFlow

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

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

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

Use when writing new functions, adding features, fixing bugs, or refactoring by applying TDD principles - write failing tests before implementation co...

Use when adding automated tests to CocoaPods libraries using test specs. Covers test spec configuration, app host requirements, and testing patterns t...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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