thebushidocollective

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

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

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

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

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

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

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

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

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

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

View GitHub Actions workflow runs and status

View CI/CD pipeline status for a merge request or project

Validate acceptance criteria for a Jira ticket without changing status

Update an existing SOP to reflect changes in tools, processes, or best practices

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

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

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

Minimize token consumption through efficient tool usage patterns

Get detailed information about a specific Jira ticket

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

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

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

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.

Write tests for code using test-driven development principles

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

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

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

Build and train neural networks with TensorFlow

Deploy and serve TensorFlow models

Create efficient data pipelines with tf.data

Get detailed information about a specific ClickUp task

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 building responsive layouts and mobile-first designs with Tailwind CSS. Covers breakpoints, container queries, and responsive utilities.

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

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 building reusable component patterns with Tailwind CSS. Covers component extraction, @apply directive, and composable design patterns.

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

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 protocol-oriented programming in Swift including protocol extensions, default implementations, protocol composition, associated types, and designing flexible, reusable abstractions that favor composition over inheritance.

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.

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

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

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

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 or modifying Storybook stories for components. Ensures stories follow CSF3 format, properly showcase component variations, and build successfully.

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

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

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

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

Start work on a Jira ticket (transition to In Progress)

Use when building reliable and scalable distributed systems.

Use when building comprehensive monitoring and observability systems.

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

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

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 updating, versioning, deprecating, or maintaining existing Standard Operating Procedures. Covers keeping SOPs accurate, relevant, and synchronized with implementation changes.

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

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

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

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

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

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

Reduce token waste by batching tool calls and avoiding narration between sequential operations

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

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

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

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 following modern best practices. Covers portable scripting, Bash patterns, error handling, and secure coding.

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

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

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

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

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

Search for code across GitHub repositories

Search for Jira tickets using JQL or text

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 scala's advanced type system including generics, variance, type bounds, implicit conversions, type classes, higher-kinded types, path-dependent types, and abstract type members for building type-safe, flexible APIs.

Use when functional programming patterns in Scala including higher-order functions, immutability, pattern matching, algebraic data types, monads, for-comprehensions, and functional composition for building robust, type-safe applications.

Use when scala collections including immutable/mutable variants, List, Vector, Set, Map operations, collection transformations, lazy evaluation with views, parallel collections, and custom collection builders for efficient data processing.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Get comprehensive review of a GitHub pull request

Get comprehensive review of a GitLab merge request

Multi-agent code review with confidence-based filtering

Resume work on a pull request by loading its context, diff, CI status, and review comments

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

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

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

Restructure code to improve quality without changing behavior

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

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

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

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

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

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

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

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 styling React Native components with StyleSheet, Flexbox layout, responsive design, and theming. Covers platform-specific styling and design systems.

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

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

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

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

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

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

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

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

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

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

Run custom queries on Sentry events and issues with advanced filtering

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

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

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

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

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

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

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

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

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

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

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

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

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 setting up or organizing Claude Code project memory (CLAUDE.md, .claude/rules/) for better context awareness, consistent behavior, and project-specific instructions.

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

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

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

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

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

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

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

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 writing Gherkin feature files, using Scenario Outline with Examples, applying tags for test organization, and leveraging Background sections for shared setup.

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

Create tactical implementation plan for a feature or task

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

Use when modern PHP features including typed properties, union types, match expressions, named arguments, attributes, enums, and patterns for writing type-safe, expressive PHP code with latest language improvements.

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.

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

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

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

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

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

Optimize code for performance, readability, or efficiency

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

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

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

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

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

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

Use when leaving structured notes, comments, and annotations in code. Covers AI note-taking patterns, TODO formats, context preservation, and development breadcrumbs for future AI assistants and human developers.

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 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 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 next.js Server Components for optimal performance. Use when building data-intensive Next.js 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 App Router with layouts, loading states, and streaming. Use when building modern Next.js 13+ applications.

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

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

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

Show all Jira tickets assigned to you

Show all ClickUp tasks assigned to you

Show all Linear issues assigned to you

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

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

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

Monitor a GitLab pipeline or job until completion, reporting status changes and failures in real-time

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Use when lua tables as the universal data structure including arrays, dictionaries, objects, metatables, object-oriented patterns, data structures, and advanced table manipulation for building flexible, efficient Lua applications.

Use when lua coroutines for cooperative multitasking including coroutine creation, yielding and resuming, passing values, generators, iterators, asynchronous patterns, state machines, and producer-consumer implementations.

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 types, metatables in C, and performance optimization techniques.

Load PR context for the current branch using GitHub MCP tools

Load MR context for the current branch using GitLab MCP tools

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 managing environment-specific Kubernetes configurations with Kustomize overlays and patches.

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

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

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

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

Use when writing and deploying Kubernetes manifests for container orchestration.

Use when kotlin's null safety system including nullable types, safe calls, Elvis operator, smart casts, and patterns for eliminating NullPointerExceptions while maintaining code expressiveness and clarity.

Use when domain-specific language design in Kotlin using type-safe builders, infix functions, operator overloading, lambdas with receivers, and patterns for creating expressive, readable DSLs for configuration and domain modeling.

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

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

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

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

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

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

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

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

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

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

Get detailed information about a specific Linear issue

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

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

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

Investigate recent errors and exceptions in your Sentry projects

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

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

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

Manage incident response workflow with Sentry alerts and issue tracking

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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 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 configuring GitLab CI/CD variables, managing secrets, or integrating with external secret providers. Covers secure credential handling.

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

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

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

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

Manage git worktrees - list active worktrees, prune stale ones, and merge work back into the main branch.

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

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

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

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

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

Debug and fix bugs, errors, or unexpected behavior

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

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

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

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

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

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

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

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

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

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

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

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

Prefer explicit configuration over framework defaults to prevent environment-dependent failures

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

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

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

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

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

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.

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

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

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

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

Use when @effect/schema patterns including schema definition, validation, parsing, encoding, and transformations. Use for type-safe data validation 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 Effect error handling patterns including catchAll, catchTag, either, option, and typed errors. Use for handling expected errors in Effect applications.

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

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 concurrency patterns including fibers, fork, join, parallel execution, and race conditions. Use for concurrent operations in Effect applications.

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

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 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 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 creating bidirectional links between code and documentation. Covers link patterns, documentation references, context preservation across artifacts, and maintaining synchronization between code and docs.

Generate or update documentation for code, APIs, or systems

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

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

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

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

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

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

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

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

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

Guides end-to-end feature development through 8 phases: discover requirements, explore codebase patterns, clarify ambiguities with the user, design architecture, implement with TDD, run multi-agent code review, validate all quality gates, and write a blog post. Use when asked to add a feature, implement a new capability, build functionality, or develop a feature end-to-end.

Investigate and diagnose issues without necessarily fixing them

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

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

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

Writing effective step definitions and organizing test code

Core Cucumber concepts, Gherkin syntax, and feature file structure

Cucumber best practices, patterns, and anti-patterns

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

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

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

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

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

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

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

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

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

Create a new Standard Operating Procedure (SOP) file with proper structure

Create a new pull request in a GitHub repository

Create a new merge request in a GitLab project

Create a new issue in a GitHub repository

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

Create a new Jira ticket interactively

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

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

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

Mark a Jira ticket as complete after validating acceptance criteria

Add a comment to a Jira ticket

Code review a pull request

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 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 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 publishing CocoaPods libraries to CocoaPods Trunk. Covers pod trunk registration, podspec validation, version management, and publishing best practices for successful library distribution.

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 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 applying Clippy lint categories for Rust code including correctness, performance, style, and custom lint configuration.

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

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

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

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

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

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

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

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

Check release health and compare error rates across deployments

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

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

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

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

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 working with Bun's runtime APIs including file I/O, HTTP servers, and native APIs. Covers modern JavaScript/TypeScript execution in Bun's fast runtime environment.

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

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

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 when creating or updating technical blueprint documentation for new features, API changes, or architectural modifications. Always search existing blueprints first to avoid duplication, then write with proper structure.

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

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

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

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

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

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

Core BDD concepts, philosophy, and the Three Amigos practice

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.

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

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 creating page layouts without real content. Templates define the skeletal structure of pages using organisms, molecules, and atoms.

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 building complex organisms from molecules and atoms like headers, footers, product cards, and sidebars. Organisms are distinct UI sections.

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

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

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

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

Design system architecture and high-level technical strategy

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

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

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

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

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

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

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

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

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

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

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

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

Analyze performance metrics and identify slow transactions in Sentry

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

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

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 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 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 configuring Docker environments for act, selecting runner images, managing container resources, or troubleshooting Docker-related issues with local GitHub Actions testing.

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

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

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