han

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

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

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

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

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

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.

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

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

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 project-specific instructions.

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

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

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

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

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

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

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

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

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

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

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.

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

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.

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

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

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 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 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 standard library including Enumerable, File I/O, Time/Date, Regular Expressions, and core classes.

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

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 directly in stories.

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

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

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

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

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.

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.

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

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

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

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

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

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

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.

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

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

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

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.

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 defining data structures using Ecto schemas including fields, associations, embedded schemas, and schema metadata. Use for modeling domain data in Elixir applications.

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

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

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

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

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

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.

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

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

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

Cucumber best practices, patterns, and anti-patterns

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 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 configuring networks and service communication in Docker Compose including bridge networks, overlay networks, service discovery, and inter-service communication.

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 optimizing GraphQL API performance with query complexity analysis, batching, caching strategies, depth limiting, monitoring, and database optimization.

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

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

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 FastAPI validation with Pydantic models. Use when building type-safe APIs with robust request/response validation.

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 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 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 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 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 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 dependencies and scalable workspace configurations.

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

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

Master Python asynchronous programming with asyncio, async/await,

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

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

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

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

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

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 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 creating incident response procedures and on-call playbooks. Covers incident management, communication protocols, and post-mortem documentation.

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 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 writing shell scripts that need to run across different systems, shells, or environments. Covers POSIX compatibility and platform differences.

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

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

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

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 typeScript async patterns including Promises, async/await, and async iterators with proper typing. Use when writing asynchronous TypeScript code.

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

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

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

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

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

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

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 local GitHub Actions 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.

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.

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 configuring Ameba rules and settings for Crystal projects including .ameba.yml setup, rule management, severity levels, and code quality enforcement.

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 building modular Angular applications requiring dependency injection with providers, injectors, and services.

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

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 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 managing blueprints directory structure and avoiding duplication. Always search_blueprints before creating to prevent duplicate documentation. Handles naming conventions and cross-references.

Use when creating or updating technical blueprint documentation for new features, API changes, or architectural modifications. Always use search_blueprints first to avoid duplication, then write_blueprint with proper structure.

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 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 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 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 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 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 planning git branching strategies or managing branches for development. Helps create clear development narratives through effective branch organization and workflow patterns.

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.

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.

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

Use when building comprehensive monitoring and observability systems.

Use when building reliable and scalable distributed systems.

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

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

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.

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.