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

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

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.

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

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.

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

Structured logging with proper levels, context, PII handling, centralized aggregation. Use for application logging, log management integration, distributed tracing, or encountering log bloat, PII exposure, missing context errors.

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

Build and train neural networks with TensorFlow

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.

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.

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.

Bun package manager commands (install, add, remove, update), workspaces, lockfiles, npm/yarn/pnpm migration. Use for dependency management with Bun.

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

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 working with TypeScript's type system including strict mode, advanced types, generics, type guards, and compiler configuration.

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.

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

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

Use when C++ templates and metaprogramming including template specialization, SFINAE, type traits, and C++20 concepts.

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

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

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

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

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.

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.

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

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

Implements CSRF protection using synchronizer tokens, double-submit cookies, and SameSite attributes. Use when securing web forms, protecting state-changing endpoints, or implementing defense-in-depth authentication.

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

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

Create efficient data pipelines with tf.data

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

Use when fundamental C data structures including arrays, structs, linked lists, trees, and hash tables with memory-efficient implementations.

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.

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

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.

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

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

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

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

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.

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.

Generate or update documentation for code, APIs, or systems

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

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

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

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

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.

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

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.

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

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

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

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 when managing memory in C programs with malloc/free, pointers, and avoiding common memory safety pitfalls.

Use when c systems programming including file I/O, processes, signals, and system calls for low-level system interaction.

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.

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

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

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

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 clear operational procedures.

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

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

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

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

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

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 jest configuration, setup files, module resolution, and project organization for optimal testing environments.

Optimize code for performance, readability, or efficiency

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

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

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

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 advanced Pytest features including markers, custom assertions, hooks, and coverage configuration.

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

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

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 designing solutions, adding features, or refactoring by applying KISS, YAGNI, and Principle of Least Astonishment to write simple, predictable code.

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 implementing MVVM, clean architecture, dependency injection with Hilt, or structuring Android app layers.

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

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

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

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

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

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

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