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.
solid-principles
Use during implementation when designing modules, functions, and components requiring SOLID principles for maintainable, flexible architecture.
simplicity-principles
Use when designing solutions, adding features, or refactoring by applying KISS, YAGNI, and Principle of Least Astonishment to write simple, predictable code.
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.
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.
cucumber-best-practices
Cucumber best practices, patterns, and anti-patterns
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.
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.
cucumber-fundamentals
Core Cucumber concepts, Gherkin syntax, and feature file structure
cucumber-step-definitions
Writing effective step definitions and organizing test code
cypress-advanced
Use when advanced Cypress features including custom commands, plugins, and network stubbing.
cypress-ci-cd
Use when cypress CI/CD integration including parallelization, test recording, and media capture.
cypress-fundamentals
Use when cypress fundamentals including commands, assertions, fixtures, and E2E testing patterns.
professional-honesty
Use when responding to questions or providing information requiring professional honesty and directness over excessive agreeableness.
docker-compose-basics
Use when defining and running multi-container Docker applications with Docker Compose YAML configuration.
playwright-fixtures-and-hooks
Use when managing test state and infrastructure with reusable Playwright fixtures and lifecycle hooks for efficient test setup and teardown.
playwright-page-object-model
Use when creating page objects or refactoring Playwright tests for better maintainability with Page Object Model patterns.
docker-compose-networking
Use when configuring networks and service communication in Docker Compose including bridge networks, overlay networks, service discovery, and inter-service communication.
docker-compose-production
Use when deploying Docker Compose applications to production including security hardening, resource management, health checks, logging, monitoring, and high-availability patterns.
gitlab-ci-artifacts-caching
Use when configuring artifacts for inter-job data passing or caching for faster builds. Covers cache strategies and artifact management.
gitlab-ci-best-practices
Use when optimizing GitLab CI/CD pipelines for performance, reliability, or maintainability. Covers pipeline optimization and organizational patterns.
playwright-test-architecture
Use when setting up Playwright test projects and organizing test suites with proper configuration and project structure.
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.
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.
gitlab-ci-variables-secrets
Use when configuring GitLab CI/CD variables, managing secrets, or integrating with external secret providers. Covers secure credential handling.
graphql-inspector-audit
Use when auditing GraphQL operations for complexity metrics, depth analysis, directive usage, or query performance concerns.
graphql-inspector-ci
Use when setting up GraphQL Inspector in CI/CD pipelines, GitHub Actions, or GitLab CI for automated schema validation.
graphql-inspector-diff
Use when detecting breaking changes between GraphQL schema versions, comparing schemas across branches, or validating schema migrations.
graphql-inspector-validate
Use when validating GraphQL operations/documents against a schema, checking query depth, complexity, or fragment usage.
graphql-performance
Use when optimizing GraphQL API performance with query complexity analysis, batching, caching strategies, depth limiting, monitoring, and database optimization.
graphql-resolvers
Use when implementing GraphQL resolvers with resolver functions, context management, DataLoader batching, error handling, authentication, and testing strategies.
rspec-advanced
Use when advanced RSpec features including custom matchers, shared examples, metadata, and hooks.
mise-environment-management
Use when managing environment variables and project settings with Mise. Covers env configuration, direnv replacement, and per-directory settings.
react-performance
Use when React performance optimization including memoization, lazy loading, and virtualization. Use when optimizing React applications.
cpp-templates-metaprogramming
Use when C++ templates and metaprogramming including template specialization, SFINAE, type traits, and C++20 concepts.
crystal-concurrency
Use when implementing concurrent programming in Crystal using fibers, channels, and parallel execution patterns for high-performance, non-blocking 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.
crystal-macros
Use when implementing compile-time metaprogramming in Crystal using macros for code generation, DSLs, compile-time computation, and abstract syntax tree manipulation.
csharp-async-patterns
Use when C# asynchronous programming with async/await, Task, ValueTask, ConfigureAwait, and async streams for responsive applications.
csharp-linq
Use when lINQ (Language Integrated Query) with query and method syntax, deferred execution, expression trees, and performance optimization.
csharp-nullable-types
Use when C# nullable reference types and value types for null safety, nullable annotations, and patterns for handling null values.
elixir-ecto-patterns
Use when Elixir Ecto patterns including schemas, changesets, queries, and transactions. Use when building database-driven Elixir applications.
elixir-otp-patterns
Use when Elixir OTP patterns including GenServer, Supervisor, Agent, and Task. Use when building concurrent, fault-tolerant Elixir applications.
elixir-pattern-matching
Use when Elixir pattern matching including function clauses, case statements, with statements, and destructuring. Use for elegant control flow.
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.
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.
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.
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.
Gleam Erlang Interop
Use when gleam-Erlang interoperability including calling Erlang code from Gleam, using Erlang libraries, external functions, working with Erlang types, NIFs, and leveraging the BEAM ecosystem from Gleam applications.
Gleam Type System
Use when gleam's type system including algebraic data types, custom types, pattern matching, generic types, type inference, opaque types, exhaustive checking, and functional error handling for building type-safe Erlang VM applications.
Page 443 of 1403 · 70114 results
